From a9ca514a8402434d8384fbe8dea2f3806d7c1b69 Mon Sep 17 00:00:00 2001 From: Jim Amsden Date: Thu, 21 Nov 2024 08:22:22 -0500 Subject: [PATCH 1/5] Initial review updates of LDM Specification More changes are needed: Possibly remove Direction, define the vocabulary terms used in the POST entity request body, clarify config aware is optional in the intro, further considerations on authentication, support for additional properties is optional --- specs/ldm/link-discovery-management-spec.html | 252 ++++++++---------- 1 file changed, 109 insertions(+), 143 deletions(-) diff --git a/specs/ldm/link-discovery-management-spec.html b/specs/ldm/link-discovery-management-spec.html index 426efb0..a7f0ba2 100644 --- a/specs/ldm/link-discovery-management-spec.html +++ b/specs/ldm/link-discovery-management-spec.html @@ -5,8 +5,8 @@ OSLC Link Discovery Management Version 1.0. Part 1: Specification + + + +
+

+ This specification defines the OSLC Product Lifecycle Management (PLM) domain, a RESTful web services interface + for the PLM v2 resources and relationships between those and related resources such as product change requests, + activities, tasks, requirements or test cases. To support these scenarios, this specification defines a set of + HTTP-based RESTful interfaces in terms of HTTP methods: GET, POST, PUT and DELETE, as well as HTTP response + codes, content type handling and resource formats. +

+
+ +
+ +
+ +
+

Introduction

+

+

+ This specification defines a RESTful web services interface for the Product Lifecycle Management (PLM) domain. + This domain addresses the management of physical and logical designs of products and parts, and relationships + with other OSLC resources such as requirements, testing resources and change requests. To support these + scenarios, this specification defines a set of HTTP-based RESTful interfaces in terms of HTTP methods: GET, + POST, PUT and DELETE, HTTP response codes, content type handling and resource formats. +

+

+ The intent of this specification is to define the capabilities needed to support integration scenarios and not + to provide a comprehensive interface to Product Lifecycle Management. +

+

+ This specification is a [[!OSLCCore3]] compliant specification, and as such most of its content are references + to [[!OSLCCore3]]. +

+ +
+

Terminology

+
+
PLM Client
+
+ An implementation of the OSLC PLM specifications as a client. OSLC PLM Clients consume services provided by + PLM servers. +
+ +
PLM Server
+
+ A server implementing the OSLC PLM domain specifications. OSLC PLM clients consume services provided by PLM + Servers. The use of the terms Client and Server are intended to distinguish typical consumers and providers + of OSLC resources in a distributed environment based on REST. A particular application component could be a + client for some OSLC domain services and a server for the same or another domain. +
+
+
+

References

+
+
+ +
+

Overview

+

+ This specification defines a vocabulary for OSLC Product Lifecycle Management resources. The intent is to define resources needed to support common integration scenarios and not to provide a comprehensive definition of product lifecycle management resources. +

+ The following is an overview of the PLM specification. The specification includes classes: Part, PartUsage, LogicalDesign and PhysicalDesign, and Dimension; links between these within the PLM domain and links to classes in other OSLC domains. +

+
+ +
PLM Overview Diagram
+
+ 
+@prefix oslc_plm: .
+@prefix dc: .
+@prefix dcterms: .
+
+# teamcenter plm namespaces
+@prefix tc_plm_material: . 
+@prefix tc_plm: . 
+
+
+  a oslc_plm:Part;
+  dcterms:title "Brake Housing"@en;
+  dcterms:description "A caliper housing that holds the brake shoes."@en;
+  tc_plm:weight "1.2 kg";
+  tc_plm:material tc_plm_material:steel;
+  dcterms:identifier "gs-001-15489";
+  oslc_plm:boundingBox[
+    a oslc_plm:Dimension;
+    oslc_plm:height: "10 cm";
+    oslc_plm:width: "20 cm"; 
+    oslc_plm:length: "10 cm"];
+  tc_plm:relatedTo ;
+  oslc_plm:composedOf .
+
+
+  a oslc_plm:PartUsage;
+  oslc_plm:represents .
+  
+
+  a oslc_plm:Part;
+  dcterms:title "Brake Shoe"@en;
+  dcterms:description "A brake shoe carries the brake lining inside brake drums."@en;
+  tc_plm:weight "3.2 kg";
+  tc_plm:material tc_plm_material:ceramic;
+  dcterms:identifier "gs-001-15489";
+  oslc_plm:boundingBox[
+    a oslc_plm:Dimension;
+    oslc_plm:height: "5 cm";
+    oslc_plm:width: "5 cm"; 
+    oslc_plm:length: "10 cm"];
+  tc_plm:relatedTo .	
+
+
+ +
+

Base Requirements

+ +

+ The following sub-sections define the mandatory and optional requirements for an OSLC PLM (OSLC PLM) server. +

+ +
+

Base Compliance

+

+ This specification is based on [[!OSLCCore3]]. OSLC PLM servers MUST be compliant with both the core + specification, MUST follow all the mandatory requirements in the normative sections of this specification, and + SHOULD follow all the guidelines and recommendations in both these specifications. +

+ +

+ An OSLC PLM server MUST implement the domain vocabulary defined in + OSLC Product Lifecycle Management Version 1.0. Part 2: Vocabulary +

+ +

+ The following table summarizes the requirements from OSLC Core Specification as well as some additional + requirements specific to the PLM domain. Note that this specification further restricts some of the + requirements from the OSLC Core Specification. See the previous sections in this specification or the OSLC + Core Specification to get further details on each of these requirements. +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +
RequirementMeaning
Absolute URIs + PLM Servers MUST use absolute URIs for all references to resources by properties +
Unknown properties and content + PLM Servers MAY ignore unknown content and PLM clients MUST preserve unknown content. PLM Servers MAY + discard such properties and continue the POST or PUT operation without warning to the client. +
Resource OperationsPLM Servers MUST support resource operations via standard HTTP operations
Update and Delete + PLM Servers SHOULD support resource modifications with standard HTTP PUT and DELETE methods. PLM Servers + MAY limit modifications +
HTTP If-Match use + PLM Servers supporting update and delete of resources MUST support the standard HTTP If-Match header in + PUT and DELETE for concurrency protection of resources. +
Resource Paging + PLM Servers MAY provide paging for resources but only when specifically requested by clients +
Partial Resource Representations + PLM Servers MAY support requests for a subset of a resource's properties via the oslc.properties URL + parameter retrieval via HTTP GET +
Partial Update + PLM Servers MAY support partial update of resources via the oslc.properties URL parameter retrieval via + HTTP PUT and or using [[LDPPatch]]. +
Discovery + PLM Servers MAY provide a Service Provider Catalog, MUST provide a Service Provider resource, and MAY + provide other forms of discovery described in [[!OSLCCore3]]. +
Creation Factories + PLM Servers MAY provide creation factories for resource formats that it supports. PLM Servers MAY + support creation factories for OSLC PLM defined resources formatted as application/rdf+xml. PLM Servers + MAY support creation factories for other formats, and indicate such creation factories with a + non-default identifier in the oslc:usage property of the creation factory definition in the service + provider document +
Query Capabilities + PLM Servers MUST provide query capabilities on PLM resources to enable clients to query for resources. + PLM Servers MAY support the full query syntax for LinkType resources. +
Query SyntaxOSLC query capabilities MUST support the OSLC Core Query Syntax
Delegated Dialogs + PLM Services SHOULD offer selection delegated dialogs and MAY offer creation delegated dialogs specified + via service provider resource +
Resource Preview + PLM Services SHOULD offer resource previews for resources that may be referenced by other resources +
Authentication + PLM Services SHOULD follow the recommendations for Authentication specified in [[!OSLCCore3]] +
Error Responses + PLM Servers SHOULD provide error responses using OSLC Core defined error formats +
RDF/XML RepresentationsPLM Servers MUST support RDF/XML representations for OSLC Defined Resources
XML Representations + PLM Servers MUST support XML representations that conform to the OSLC Core Guidelines for XML +
JSON Representations + PLM Servers MAY support JSON representations; those which do MUST conform to the OSLC Core Guidelines + for JSON +
HTML RepresentationsPLM Servers MAY provide HTML representations for GET requests
+
+ +
+

Specification Versioning

+ +

This specification follows the specification version guidelines given in [[!OSLCCore3]].

+
+ +
+

Namespaces

+ +

+ In addition to the namespace URIs and namespace prefixes oslc, rdf, + dcterms and foaf defined in [[!OSLCCore3]], OSLC PLM defines the namespace URI of + http://open-services.net/ns/plm# with a preferred namespace prefix of oslc_plm. +

+
+
+

Resource Formats

+ +

+ In addition to the requirements for resource representations in [[!OSLCCore3]], this section outlines further + refinements and restrictions. +

+ +

For HTTP GET/PUT/POST requests on all OSLC PLM and OSLC Core defined resource types,

+ +
    +
  • + PLM Servers MUST support RDF/XML representations with media-type application/rdf+xml. PLM + Clients SHOULD be prepared to deal with any valid RDF/XML document. +
    • +
  • + PLM Servers MUST support XML representations with media-type application/xml. The XML + representations MUST follow the guidelines outlined in the + OSLC Core Representations Guidance + to maintain compatibility with [[!OSLCCore2]]. +
    • +
  • + PLM Servers MAY support JSON representations with media-type application/json. The JSON + representations MUST follow the guidelines outlined in the + OSLC Core Representations Guidance + to maintain compatibility with [[!OSLCCore2]]. +
    • +
+
+ +
+

Resource Operations

+ +

+ For compatibility with OSLC 2.0, OSLC PLM Servers MAY accept the OSLC Core Version header (OSLC-Core-Version: + 2.0) in any HTTP request as specified in [[!OSLCCore3]], and return an OSLC PLM 2.0 representation (including + the OSLC-Core-Version: 2.0 header). If the OSLC Core Version header is absent on a request, or has some + undefined value, the OSLC PLM Server MUST return an PLM 2.0 representation. +

+ +

+ OSLC PLM Servers MUST support HTTP GET requests on PLM Resources, with an Accept header of + application/rdf+xml, and return the RDF/XML representation of the resource. +

+ +

+ OSLC PLM Servers SHOULD support HTTP GET requests on PLM Resources, with an Accept header of an HTML type ( + application/html, application/xhtml), and return either an HTML/XHTML representation + of the resource or redirect the client to another URL that can (i.e. 302 Redirect). +

+ +

+ OSLC PLM Servers SHOULD support HTTP GET requests for user interface (UI) preview of PLM Resources as defined + by [[!OSLCPreview]]. +

+ +

+ OSLC PLM Servers SHOULD support resource modifications on PLM Resources with standard HTTP PUT and DELETE + methods. PLM Servers MAY limit modifications in any way they want. For example a service provider may limit + updates to resources to simple link properties of link types already defined in the provider. Modification + methods MUST use the If-Match header for concurrency management. Providers MAY discard such properties and + continue a PUT operation without warning to the client. +

+ +

+ OSLC PLM Servers SHOULD support resource modifications on LinkType Resources (LTR) with standard HTTP PUT and + DELETE methods. PLM Servers MAY limit modifications in any way they want. For example a service provider may + not support additional properties. Modification methods SHOULD use the If-Match header for concurrency + management. +

+
+ +
+

Authentication

+ +

See [[!OSLCCore3]], OSLC PLM puts no additional constraints on authentication.

+
+ +
+

Error Responses

+ +

See [[!OSLCCore3]], OSLC PLM puts no additional constraints on error responses

+
+ +
+

Pagination

+ +

+ OSLC PLM Servers SHOULD support pagination of query results and MAY support pagination of a single resource's + properties as defined by [[!OSLCCore3]]. +

+
+ +
+

Requesting and Updating Properties

+ +
+

Requesting a Subset of Properties

+ +

+ An OSLC PLM server MAY support the oslc.properties URL query parameter on an HTTP GET request + on individual resource request or a collection of resources by query. If the + oslc.properties query parameter is omitted on the request, then all resource properties MUST be + provided in the response. +

+
+ +
+

Updating a Subset of Properties

+ +

+ An OSLC PLM client MAY request that a subset of a resource's properties be updated by identifying those + properties to be modified using the oslc.properties URL parameter on a HTTP PUT request. +

+
+ +
+

Updating Multi-Valued Properties

+ +

+ An OSLC PLM Server MAY support updating a subset of a resource's properties by using the [[LDPPatch]] + PATCH method. +

+ +

+ For compatibility with [[!OSLCCore2]], an PLM Server MAY also support partial update by identifying those + properties to be modified using the oslc.properties URL parameter on a HTTP PUT request. +

+ +

+ If the parameter oslc.properties contains a valid resource property on the request that is not + provided in the content, the server MUST set the resource's property to a null or empty value. If the + parameter oslc.properties contains an invalid resource property, then a + 409 Conflict MUST be returned. +

+
+
+
+ +
+

Vocabulary Terms and Constraints

+

+ OSLC PLM Resources 2.1 Defines the vocabulary terms and constraints for OSLC + Product Lifecycle Management resources. These terms and constraints are specified according to [[!OSLCCore3]]. +

+
+ +
+

PLM Server Capabilities

+ +
+

Resource Shapes

+ +

OSLC PLM servers SHOULD support Resource Shapes as defined in [[!OSLCShapes]].

+
+ +
+

Service Provider Resources

+ +

+ OSLC PLM Servers MUST provide a ServiceProvider Resource that can be retrieved at a implementation dependent + URI. +

+ +

+ OSLC PLM Servers MUST provide a ServiceProviderCatalog Resource that can be retrieved at a implementation + dependent URI. +

+ +

+ OSLC PLM Servers MUST provide an oslc:serviceProvider property for their defined resources that + will be the URI to a ServiceProvider Resource. This does not prevent PLM Servers from providing multiple + servie provider properties with different values, if the service provider supports multiple OSLC domain + specifications, and the resource is applicable to multiple domains. +

+ +

+ OSLC PLM Servers MUST supply a value of http://open-services.net/ns/plm# for the property + oslc:domain on either oslc:ServiceProvider or + oslc:ServiceProviderCatalog resources. +

+
+ +
+

Creation Factories

+ +

OSLC PLM Servers MAY support CreationFactories as defined by [[!OSLCCore3]].

+ +

+ OSLC PLM Servers MAY discard properties it does not recognize and continue the POST operation without warning + to the client. The returned resource will contain the accepted properties (and server generated properties + like the dcterms:identifer) so clients will be able to confirm if required what was accepted. +

+ +

+ If OSLC PLM Servers support the creation of resources from the OSLC defined + oslc_plm:Part format, there MUST be at least one Creation Factory entry in the Services + definition, and its oslc:usage property MUST be set to + http://open-services/ns/core#default. The oslc:resourceType MUST be set to + http://open-services.net/ns/plm#Part. +

+ +

+ If OSLC PLM Servers support the creation of resources from a resource other than + oslc_plm:Part, there MUST be a separate creation services definition whose + oslc:usage property MUST NOT be set to http://open-services/ns/core#default. +

+
+ +
+

Query Capabilities

+ +

+ OSLC PLM Servers SHOULD support the Query Capabilities as defined by [[!OSLCCore3]] for all PLM resources. +

+ +

+ If the service provider supports query capability for PLM resources, it MUST support the following query + parameters: +

+ +
    +
  • oslc.where
    • +
  • oslc.searchTerms
    • +
+
+ +
+

Delegated UIs

+ +

+ OSLC PLM Servers SHOULD support the selection of resources by delegated selection dialogs as defined by + [[!OSLCCore3]]. +

+ +

+ OSLC PLM Servers MAY support the creation of resources by delegated creation dialogs as defined by + [[!OSLCCore3]]. +

+ +

+ In oslc:Dialog elements, the two optional child elements; oslc:hintWidth and + oslc:hintHeight specify the suggested size of the dialog or frame to render the HTML content in. + Expected size values are defined by CSS length units. +

+
+
+ +
+ +
+

Acknowledgements

+

+ The following individuals have participated in the creation of this specification and are gratefully + acknowledged: +

+ +

Participants:

+

+ James Amsden, MID (Editor)
+ Ed Gentry, MID (Editor)
+

+
+ + diff --git a/specs/plm/plm-vocab.html b/specs/plm/plm-vocab.html new file mode 100644 index 0000000..7c062bc --- /dev/null +++ b/specs/plm/plm-vocab.html @@ -0,0 +1,347 @@ + + + + + OSLC Product Lifecycle Management Version 1.0. Part 2: Vocabulary + + + + + + +
+ This specification defines the OSLC vocabulary terms for + OSLC Product Lifecycle Management Version 1.0. Part 1: Specification, and OSLC + representation of the OMG Systems Modeling Language v2. +
+ +
+
+ +
+

Introduction

+ +

+ This specification defines vocabulary terms for OSLC Product Lifecycle Management Version 1.0 + resources. The intent is to define resources needed to support common PLM integration scenarios. The resource + formats are intended to define RDF resources that enable model elements in typical PLM methods to integrate with + other OSLC resources including Requirements, Archaitecture Management Resources, Change Requests, Test case, + etc. +

+ +
+

Terminology

+

+ Terminology is based on OSLC Core Overview [[!OSLCCore3]], W3C Linked Data Platform [[!LDP]], W3C's + Architecture of the World Wide Web [[WEBARCH]], Hyper-text Transfer Protocol [[!HTTP11]]. Terminology for this + specification is defined in part 1 of the multi-part specification. +

+
+ +

References

+ +
+

+

+ In addition to the namespace URIs and namespace prefixes oslc, rdf, + dcterms and foaf defined in the + OSLC Core specification, OSLC PLM defines the namespace URI of http://open-services.net/ns/plm# with a namespace + prefix of oslc_plm +

+ +

This specification also uses these namespace prefix definitions:

+ +
    +
  • oslc : http://open-services.net/ns/core# [[OSLCCore3]]
    • +
  • oslc_am : http://open-services.net/ns/am# [[OSLCAM2]]
    • +
  • oslc_rm : http://open-services.net/ns/rm#OSLC Requirements Manasgement
    • +
  • oslc_qm : http://open-services.net/ns/qm#OSLC Quality Management
    • +
  • oslc_cm : http://open-services.net/ns/cm#OSLC Change Management
    • +
  • oslc_config : http://open-services.net/ns/config#OSLC Configuration Managemt
    • +
+
+
+ +
+

PLM Vocabulary Terms

+

Property value types that are not defined in the following sections, are defined in [[!OSLCCore3]].

+ +

+ OSLC PLM defines a set of properties for product lifecycle management. However, service implementations are free + to extend this set of properties. Clients + MUST preserve properties it does not recognize when updating resources. OSLC PLM Servers + MAY ignore properties that it does not recognize. Additional properties may come from existing + vocabularies (ie. Dublin Core, OWL). When additional properties do not come from a known vocabulary, it is + recommended that they exist in their own unique namespace, and providers SHOULD NOT reuse + namespaces defined in these specifications. +

+ +

+ All RDF/XML resources that include links with annotations MUST begin with an outer + <rdf:RDF> element. This outer XML element is required to support the ability to include + annotations on ‘link’ properties with additional <rdf:Description> elements + reifying statements about the link. +

+ +

+ Service implementations and clients MUST be prepared to accept any form of valid RDF/XML. For example the + following two resource forms are equivalent. +

+ + 
+<rdf:RDF
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:oslc="http://open-services.net/ns/core#"
+   xmlns:oslc_plm="http://open-services.net/ns/plm#"
+   xmlns:dcterms="http://purl.org/dc/terms/">
+
+    <oslc_plm:Part rdf:about="https://example.com/resources/res1">
+      <dcterms:title>Service Interface</dcterms:title>
+      <dcterms:identifier>res1</dcterms:identifier>
+      <oslc:serviceProvider rdf:resource="http://open-services.net/ns/plm#"/>
+    </oslc_plm:Part>
+</rdf:RDF>
+
+is equivalent to
+
+<rdf:RDF
+   xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+   xmlns:oslc="http://open-services.net/ns/core#"
+   xmlns:dcterms="http://purl.org/dc/terms/">
+
+    <rdf:Description rdf:about="https://example.com/resources/res1">
+      <dcterms:title>Service Interface</dcterms:title>
+      <dcterms:identifier>res1</dcterms:identifier>
+      <rdf:type rdf:resource="http://open-services.net/ns/plm#Part" />
+      <oslc:serviceProvider rdf:resource="http://open-services.net/ns/plm#"/>
+    </rdf:Description>
+</rdf:RDF>
+
+ +

+ This specification defines a number of specific, commonly occurring vocabulary terms (OWL classes), properties + and values. Servers may define additional classes and provide additional properties as needed. +

+ +
+
+ +
+

Conformance

+

+ OSLC PLM servers MUST use the vocabulary terms defined here where required, and with the meanings defined here. +

+

OSLC PLM servers MAY augment this vocabulary with additional classes, properties, and individuals.

+
+ + diff --git a/specs/plm/plm-vocab.ttl b/specs/plm/plm-vocab.ttl new file mode 100644 index 0000000..fbee114 --- /dev/null +++ b/specs/plm/plm-vocab.ttl @@ -0,0 +1,205 @@ +# Copyright 2024 OASIS Open +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. + +@prefix dcterms: . +@prefix oslc_am: . +@prefix owl: . +@prefix rdf: . +@prefix rdfs: . +@prefix vann: . +@prefix xsd: . + +@prefix oslc_plm: . + +oslc_plm: a owl:Ontology ; + rdfs:label "OSLC PLM Vocabulary" ; + dcterms:dateCopyrighted "2012-2024" ; + dcterms:description "All vocabulary URIs defined in the OSLC Product Lifecycle Management (PLM) namespace."^^rdf:XMLLiteral ; + dcterms:hasVersion "WD" ; + dcterms:isPartOf ; + dcterms:issued "2024-08-01"^^xsd:date ; + dcterms:license ; + dcterms:publisher ; + dcterms:source ; + dcterms:title "OSLC PLM Vocabulary" ; + vann:preferredNamespacePrefix "oslc_plm" . + +# Classes defined in the OSLC PLM specification + +oslc_plm:Part a rdfs:Class ; + rdfs:subClassOf oslc_am:Resource ; + rdfs:label "Part" ; + rdfs:comment "An artifact managed by a PLM product, an element of a BOM." ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:subClassOf oslc_am:Resource . + +oslc_plm:PartUsage a rdfs:Class ; + rdfs:subClassOf oslc_am:Resource ; + rdfs:label "PartUsage" ; + rdfs:comment "The use of a part in another part." ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:subClassOf oslc_am:Resource . + +oslc_plm:LogicalDesign a rdfs:Class ; + rdfs:subClassOf oslc_plm:Part ; + rdfs:label "Logical Design" ; + rdfs:comment "The logical design of a product" ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:subClassOf oslc_am:Resource . + +oslc_plm:PhysicalDesign a rdfs:Class ; + rdfs:subClassOf oslc_plm:Part ; + rdfs:label "Physical Design" ; + rdfs:comment "The physical design of a product" ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:subClassOf oslc_am:Resource . + +oslc_plm:Dimension a rdfs:Class ; + rdfs:label "Dimension" ; + rdfs:comment "Specifies units for property types" ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:subClassOf oslc_am:Resource . + +# Properties defined in the OSLC PLM specification + +oslc_plm:alignsPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "alignsPart" ; + rdfs:comment "A Part is aligned with another Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:alignsPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "alignsPartUsage" ; + rdfs:comment "A PartUsage is aligned with another PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:composedOfPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "composedOfPartUsage" ; + rdfs:comment "A Part is composed of PartUsages. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:representsPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "representsPart" ; + rdfs:comment "A PartUsage represents a Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:realizesLogicalDesign + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "realizesLogicalDesign" ; + rdfs:comment "A PhysicalDesign realizes a LogicalDesign. It is likely that the target resource will be oslc_plm:logicalDesign." . + +oslc_plm:boundingBox + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "boundingBox" ; + rdfs:comment "An oslc_plm:boundingBox represents the rough dimension of an oslc_plm:Part. It is likely that the target resource will be a oslc_plm:Dimension.". + +oslc_plm:weight + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "weight" ; + rdfs:comment "An oslc_plm:weight represents the weight of an oslc_plm:Part.". + + + +# The following properties are intended to be supported by other OSLC domains: CM, QM and AM +# They are defined in the PLM specification, and are included as additional constraints +# in the intended domains + +# Additional properties for the CM domain + +oslc_plm:affectsPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "affectsPart" ; + rdfs:comment "A ChangeRequest affects a Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:hasProblemPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "hasProblemPart" ; + rdfs:comment "A ChangeRequest has a problem Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:hasSolutionPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "hasSolutionPart" ; + rdfs:comment "A ChangeRequest has a solution Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:relatedPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "relatedPart" ; + rdfs:comment "A ChangeRequest has a related Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:implementsPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "implementsPart" ; + rdfs:comment "A ChangeRequest implements a Part. It is likely that the target resource will be oslc_plm:Part." . + + +oslc_plm:affectsPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "affectsPartUsage" ; + rdfs:comment "A ChangeRequest affects a PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:hasProblemPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "hasProblemPartUsage" ; + rdfs:comment "A ChangeRequest has a problem PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:hasSolutionPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "hasSolutionPartUsage" ; + rdfs:comment "A ChangeRequest has a solution PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:relatedPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "relatedPartUsage" ; + rdfs:comment "A ChangeRequest has a related PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + +oslc_plm:implementsPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "implementsPartUsage" ; + rdfs:comment "A ChangeRequest implements a PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + + +# Additional properties for the QM domain + +oslc_plm:validatesPart + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "validatesPart" ; + rdfs:comment "A TestCase validates or verifies a Part. It is likely that the target resource will be oslc_plm:Part." . + +oslc_plm:validatesPartUsage + a rdf:Property ; + rdfs:isDefinedBy oslc_plm: ; + rdfs:label "validatesPartUsage" ; + rdfs:comment "A TestCase validates or verifies a PartUsage. It is likely that the target resource will be oslc_plm:PartUsage." . + + +# Additional properties for the QM domain + + diff --git a/specs/plm/pml-shapes.html b/specs/plm/pml-shapes.html new file mode 100644 index 0000000..573e306 --- /dev/null +++ b/specs/plm/pml-shapes.html @@ -0,0 +1,389 @@ + + + + + OSLC Product Lifecycle Management Version 1.0 Part 3: Constraints + + + + + + +
+

+ OSLC Product Lifecycle Management Version 1.0. Part 3: Constraints defines the standard OSLC constratint on the + RDF OSLC Product Lifecycle Management Version 1.0 vocabulary terms. +

+
+ +
+
+ +
+

Introduction

+

+ This section specifies the constraints for the PLM resources. The resource properties are not limited to the + ones defined in this specification PLM Servers may provide additional properties. It is recommended that any + additional properties exist in their own unique namespace and not use the namespaces defined in these + specifications. +

+

+ RDF vocabularies define the terms and resources for a domain of interest, life-cycle management in the case of + OSLC PLM. These vocabularies are often specified in an open manner, without providing information such as + property domain and range assertions, cardinalities, etc. This helps keep the vocabulary applicable for a wide + range of uses and furthering integration with other vocabularies. +

+

+ However, it is often desirable to closed down a vocabulary with specific constraints to facilitate using the + vocabulary for a specific purpose. This document specifies the constraints for using the OSLC PLM vocabulary in + OSLC. Different sets of constraints may be applied to a vocabulary in order to tailor its use, without overly + constraining the vocabulary for other usages. +

+ +

+ These constraints apply to the core vocabulary defined in + OSLC Product Lifecycle Management Version 1.0. Part 2: Vocabulary. +

+
+

Terminology

+

+ Terminology is based on OSLC Core Overview [[!OSLCCore3]], W3C Linked Data Platform [[!LDP]], W3C's + Architecture of the World Wide Web [[WEBARCH]], Hyper-text Transfer Protocol [[!HTTP11]]. Terminology for this + specification is defined in part 1 of the multi-part specification. +

+
+ +

References

+ +
+

+

+ In addition to the namespace URIs and namespace prefixes oslc, rdf, + dcterms and foaf defined in the + OSLC Core specification, OSLC PLM defines the namespace URI of http://open-services.net/ns/plm# with a preferred + namespace prefix of oslc_plm +

+ +

This specification also uses these namespace prefix definitions:

+ +
    +
  • oslc : http://open-services.net/ns/core# [[OSLCCore3]]
    • +
  • oslc_am : http://open-services.net/ns/am# [[OSLCAM2]]
    • +
+
+
+ +
+

Resource Constraints

+

+ This section specifies the constraints for the PLM resources. The resource properties are not limited to the + ones defined in this specification, PLM Servers may provide additional properties. It is recommended that any + additional properties exist in their own unique namespace and not use the namespaces defined in these + specifications. +

+

The following properties are should not be expected to be modifiable by a PUT, or POST.

+
    +
  • dcterms:identifier
    • +
  • dcterms:creator
    • +
  • dcterms:modified
    • +
  • decterms:created
    • +
  • oslc:serviceProvider
    • +
  • oslc:instanceShape
    • +
+ +
+

Part

+
+
+ +
+

PartUsage

+
+
+ +
+

LogicalDesign

+
+
+ +
+

PyhsicalDesign

+
+
+
+ +
+

Constraints on Other OSLC Domain Resources

+

+ OSLC PLM defines some new properties that are used in constraints to extend other OSLC domains. These + constraints are considered added to implementations of CM, QM or AM domains that wish to support the PLM domain. +

+ +
+

ChangeRequest

+
+
+ +
+

TestCase

+
+
+
+ +
+

Conformance

+

+ OSLC PLM servers MUST follow the constraints defined here where required, and with the meanings defined here. +

+

OSLC PLM servers MAY provide additional constraints for specific purposes.

+
+ + diff --git a/specs/plm/resources/OSLC PLM Domain.docx b/specs/plm/resources/OSLC PLM Domain.docx new file mode 100644 index 0000000000000000000000000000000000000000..f8a2f5dba04e292e064c92788185b8bad7fb6823 GIT binary patch literal 350473 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

I-RPRjkJN(=j?rkwicMt!HN6TvVp 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⪚@U2 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

tIyh1hH#EOC!3aMLoE1&u5rU)F*1L{md zVqgx`GzS;1UexJ|n=`BBT^LM~t2{ex$vJ%2zuUlut_;JV%R8Hy?rY?0OhVwayR#Hu zF0;HenQQGwYkJ(InE-v;vMLhFsDlaAIjhRVGGR`aShPzj&qlf1|1kM2(YKO#+oB<6 z7WA)l81gxjKdT4i(^b{JEL%;tDV@r@nWr^s9d_6Ok6w0~r-_lQI;yo_l1_n-_qGMf zbwck&e6rl`^Rh|%yxQ(H=aflN92%}3;_h>u$)!CScKuxtxrHZ-%e&zQ18BB+ML8x8 z$Mr83Vwi8lKJXU5;hjoas#nOdK5?T5bp?Mkv4=Gb01{@B_QJu@X~ekh1FpPOq=`I7 zxj6fz)%x|=lqaSKy;|xP$}9v?SX+9}xbmXs+V?u>_c~WB26pDIB1v;7#RFeDJcQ3eQH(B+%_VtSxy)-DrX+#f3_~{e zgK05OI@dP*>zp+VHu~cDk9V!>MvcpzA|nXw+J>q-K8!PRi(=3vrLZpN!>;(kW;;BvM$8 zQSY<~cS^W_ob5)p6Be!+8+za%&Kc27_C=Xmw+Ky)C)+jqmxJ^VnP)W8Jse z4U$okQG~{j=Nz}mA0eJhkHzF)SefN@Oo;iYM$U!ge<|7g>X+41<8!Na4X!863?VR# ztRNLVe~bTR>?XmLye`K1Q5&RBRF#~M6K)93)s1=G)x3O%LF3SoF$K!dF1sx+&h-+( zWXYJRzOnI=nPdOy*odTaPv z=7qf3Y&d(I;X)&4keS|(j!kd@2c?hDyEC(ju_7XrP1nM-)4C1{4cM0*ZJ3K6$IuIB z1Wb?CkC+Ummo6F%r(Z-YW}Jktn(~SaRFlMCBIUa0Te%S~=D21j%(mpuPm{(|ZEM^< zcDoR2UR?3&-a=dUr{f+o)IiqMn;i1s=OrY3xnCUsP;f1M6+Y9xd#axXA zU7SJxxys44J}v&Wiza}hF>J~_k2Gzs%b;f)5Rj+>J;*yiGX6`*oBp{M7S}Hl8=<2I z1_p|kZ7B673KM{G_XjJZ!xy20oB}_i1xNse)Gd1xh^qGc&#s&b5LH6zp9JRY+UP5T zCii0?<-GXWfj|;82n%ahhLomIPRSJU#aOd4SKuFqRe$ds8T@!#74fd5pi) zyBk{OTXmR|ApS{TjuZ*8mZp{WOIfe3GqYX$(Cs#oet-dUVwNObVEc? zUOt311<2f?A~VC0f)*=|!PQ1ukgAc*eE9@3+5S!W9{(Yt2AF9du2xDN+oz9H` zB@L6{6=&-;(7a}yp;{{OS>%s%?*&CgsqVH}{6*D6%yijoT?Wpw+fJXXa_Kst>@hCz z{79QdnrvcTL~k;n?m?h1gqO=_>@0)!iu1*Vt;D5Uw~; zX#QTaCrP@nT@`?mBRHB`o99R2v5H?eJK)r91-!>05BRa>M2pxQ5DLgK2(w0-Vq+Pu zb^cRCl@;<5VyBw7_3E}-p*iK!1j5p@qqdSJh*(a5iU{z9bX3gC1Njiav#mRBu9!Gi zJ+RW=OS8~LYQJd{o@d2<+y9DF6^$;s$#OId^IKnF zrnOG>1;uB&f^o3Re!*7Vf&e+ZHc48hu6z>eD42O=^zf6Jdw%SI3LH zWWc%VOaihz7oD{VQW!_*cZZPa-rUHt2mAd!=6n5>bNyzph&h2`P9HLWxkOd}60-G< z9{U`<;w&qewj#E%U@2YLT$uBQrFdc0==Geri5swD1v_ImGcFw87Jh)0&4JZiC*d~2 zN>-`vq7%P*AHr|l!%@jKuWF~ie~-hm#FST<_s!usX2(?r=BXK`IfTE)TtZIrP-v|K z4-N*l2Xxh>O7QFy3xzSb^e}^(h@a~e3%+C)T=D&VeWH$3mvD7@N&~OD{ z+098WrVLMjWAlz&y6gj&$VWl;yUW6$QgY$Lc4gY?FEmkLKj113>-aX;ZTMv0z#|+h zC8gH>iFSz{y71A~$g)UOt;odXO>X(R6k}?n!WHb|J#a;}$Y9*EI-oeRTd)dwVNyY_ z(O5x6_BfJoCww4V*`%s%h@e2+`kai|ZJ$?@5r=FuU8^6y_;ekvz+%^Wd(+QxcRu;C zOS}U4YPqYFBl}8190}NW>t~V#6AqXirml2xs5x$vk+5mI_8mX^1oQgHI`12JCwivL z41uYdXs_>;V7!pcO_d-UQn5Ql&1~GeFi=uPzf$YwK8v?4&@|65%C%-7mqYu>0v|tx zjEQ}Pg#_7?l4m@lZ9s}^?EtD&^4*GZ+ukb&;$eARngw~@(S!BySy2?Q;4W3rgD0lt zS(`3V9Lk+#dBp`rJ+gpNZMJK8TMItn!aP6MhVhkMx6xh)tDJ$S_Ty_VB7Veq3?=6N zl(51Kpd>1rHY%N7wZ>}Ospi!O{|u|rj(}1su@a1_Z9lwmZ#2$?chU*>OMgl!3r=K} z>(Q;H(NL%F*P`iLrWJ^&JfmAm_6fGB=0qqnHif7PIS0M-sBpSWczE%IbUZ@J_rwT&`iIE%|7-$B05Q~?dp?J!a+BnfSnuSHNFk=5~~{Ia5^vn zBW zsgk_3YY8@%&_7377*2rWFMU(@OTh*m7gZu%m`3@ z%U`X3wN|Jq7dWq+pNpv+@bY1|9u+&T>!?oN6MgNHF+$Gs68V6dnzSu${+T}yYB@G9 z>yD&d16hPRk_ZNny|j8dDQJtM)nE{pueoS)YLN^7=KkoFtIHG@oRs%zVYpNx|5e z=wwY7r&2!7G|`qO=D0yEdZohWoc`$4y8$Y{&6uFhWq8a$({Rc(cMK*vL)fyzh!pxj zKww}JaA;^}r}FahxSp6IE178yqUp+=a0{Sk*quN?iZ!K|JDI=IW%k3v{J3bJkKtQt zBwldfQ;|j3U*W&6vTuC-&R?-XgV=Wf((9QX*tIL}Q!*Sa;GEiji)MD6bik#C0JO&73A-Kax?a~Et=2wfs6J-q2h#1goDOzE z^0WwC_gY|XKn^mLF1tcax}EvA%&kDt=Ps&jS@3vml*qtO}r3igV zAV!cH*;5rI7It5HFQO(&fNm%`$Uug>>uhCCp;|<-aUdm~d`omCGV!T22SH{iRd{7q ztVqPXxMt>sZm3;q7$c5y`7_ou4RrX9@J$BdNV{-L-BFQC5%el8Xr%m=)?}~|Z$>|3 z9jgM@t8J86Co^;Y<;EeL*_C3JYeR`=7S@O7#5g)I;AL12V@JGlp;wE$YRKS}fb30VsAT5uHMd7{Pfs66V6e3>YmCyg9Xo2`GtKzN#2(FVrCX}@Pt4)qi^f!^>^^^CuI^DIY(>?0W^Q*yeS6U zYQ;J_7}I!ndFL$#kWwfEGGfI5xJ{6z*9lZ69@BMO07xksauFgDOnVhMXXJ)%`kkjC zRshvIbKAtBr)*I-FiQMk?h;+Gpxfk5FjSh+T{17#BuIwu%lEfr6eS=sBHJ zz>)u$|JN=7&hKsU+vCm{(-DF^qv`h({jW!TvioF39#wJ~&OE^X6Zr^&ZDaK7V=R`< zGSZASZb!yWUIwbA=5ruNp(^mu50f@L7aQ$j?tbpbyEm9%_WYxOh!>5RVS*> zwzeR2zjyh*<$I04Ppu{U`tt>g?|^IeWb|A#X^1;>+ROYzQ;-AAj1|Itt6b$+dI(z6 z@-$nn00x14Qs%Im7ScQ3EFI_y!-=#xav34A8S>(w#gMDknuEl<=;u)jz{{rSN&3-L zW=*QZ#{|!U1L`fFJr~fF-EY$V-VyMJxg8VfjuiNRB-;+}%TzoY=z_`eJi~fT>16%= z0>jhWUmr@{eAZ%&84eh#G(j`gq{hxNQI)&31b0$pfqwsOJcYSQ6#B^AizM_1D4S21 zfP%0haojAsSn9mt5P$=D@_b$>T{O?qlx}-?=juGm+nJV%!*y_scS!C*_3Xk;Me@D~AdXEXRCh@jOqX<2nVBXYAO&{F$BN zr@Ma9SVF4K2to6@-NDadN?h-z)?@+B!fr3DX%^I5{R&qG9LQUDt)D&(Qvr3)CNHAE zZI&SCl+8YwvvoJQI81BYwuWL;v<5PV?ZRWMt2Vx7o5Q$mX6;C^e&FI`@1e|^5O&>y zu@~LqDx?3(y2D-i!C03ar^oi66XnzKLpHA^YU0#~&v{zNu$(bIIv6{;oJmu*M!~Ln zm6eyLxw(V2=V$l|a&hKN_?L<3gvTdBjAB&j6zP&@ohjBxNHj3(f{ksTOf<$l`s*e6 zaxd%ZG3!<$C+febNbWAniFbEnnopEQbzBM4s$)*R6fknW5HV9Vd}Jt_ z6;7M;$@U4A^NuIz6?~p=m|>weC?%1~+xBSEGHPeFW%5OwZO`{c4EmjXq^s zD>CKQ;)6WaT2QJ_i60eJwcyd**1@|siHK;7lypuw^NSGMIf_12Wq|?Gir_AQ>_^I{ zj^ps3Yg-+*n2WkV-U_M-ZF_5+juEBnD;2&bqe_;--6*6zO+I>na*Ma5nAk@m-Gvav zEd5~FG^IkXnV=U`!ZiRX-2w#9DPzJF?m^5zI-!91f;B)NEb<>iM82$?-^rii4mlQ6 z>&uTQ;9U~1+iXyn9h`IyJwoPJM3fk>IB~7C`wWm0T)Cn$YO8=1p<~VK%dxx1!!-J1 z>l41?dv_tVWqic?R;Pr^Wp2}Nd>&ai>iJhIjjf|(akjlzEgtQeb3da*uf-TJ8oTRT zxo`jSxYFZMwIT1(x2So%*qUm~a}hXA_}6&ngzS*z3(=HW=!gE%3TZ%qW%~&~ z2OYk|+3BtFMR(HchC(e-0M_H)K|Uz>XlSoHj=y33Li^abu>D^i`91%)SMzU%ciZyw zTsEnxuA{y3MFaJ6Tp=?)3+1#4D@D z!E6=Dba^__}9KEHEGd9qaS((JCD19<=O{aSAQ~4GSYoD@y9nV!VZYr-e?{0RP-) z@+msc?GLUG7wF~JH#R79}fE80_*|Bjh^0g4A%Emi3nsB^0mWDLFpo*WyQ)?lAVrD zbiO@|sVyYui}M8N#=lY`TK&XLA&_@&cv4B?q~VL3?b*D zZ!FvIR+dLGRf_XbVFK@c&kOzf2AN2WbxAfu!O0u<6~m7pZ7ZE*PHDH6cKn<|Y7ygW z*e!_@4f%n?+6)&D0}60GxLP*a@$P3;2mjuE$RalG-KB~b=DP5}JeQV*Jevumx#>}i z^MbF5Q-1xx^4(lk$zYG>d(|_tKd%cEQbQP5T6O13nK{Dc!JJcfXKDv`z{N@#4k#_z zt34PE(DPVEqpQBkZA~XwbaO1xr3kvsv$(02h^Xb%Iou4_jTMgw8E7l#Asw}g(lM^A zdtlS}!^Kj32FxC{mfw*EK@^Z{+wKLbmm+54{HanIs0Cxzd%ryb*PWC5#oknRIu_m~ z?xkhI$C68IE=s%F?5OF5l*B7xZ|P*EUVrdiECF@SeS3LcAXxZ;;v|51NscdF!B;4n zk!gCP6!{Cs{a@i1aLHa_UHLI3bH-@kBH7TlpDy?Rin)qBb4ID?r)PQzL|M>fJ_1f<0}T{nk;s1u4*=xgpr zZICcsGyrIvy|hHjrC#}~r2ypv`uVB&I`7o|r@pp7C+f#{&I+KuPPgYO>g$9-$D4HA zQ_Pj5P^a1E%XIfTFZn@ja08$R6(OKE%CoA-aQHTgJOuEIV~b|Y%LO0*GV*`S*U$eA z;sOj7A`{#TUI5|)QMn)>An;Og%+eF;MMS5hq1(ug>jk}NZXFwmRWz5Rdje2iqWb#! zY9Hd5{>_4)58^{T{+swh0P69k7X-rT%~73VYI~pEFOh9wv z>G@9G`MqZMU;ncKG(kF*-M%|b2p5ikprG*6r>?ts=b&dEbx`Q&_(S2Dne@mnlMaB_ zPMr*uv-uZm%x4X_m9(hqzh6^Pj};OU1xQEmSWeS#Z}0F)xXl)*f@6%d*3#PHS5VZC zy?pA3A*-OQ)F$EaBO#6eNq2%fAoG{6hA>CR`XR1y>gRs$P{X5VeiA3jTF8{fkMUL{Ve~*mRY?`Sqs$KfW{eCAI)@TgG&}S5OV0&(&In zJ=7ZiAilos~<{{7qEt3u85q=WKm&gxr5{oVI3X0#eJOB;@rO8Nf%Q<~Ml zysv)JHM@w>8Z7Qdpu`qP;A245aic%f+*9jp=XBas!YrT&K=ZZuAJ+1#5r}-?vur65 z%g#%^z>=me^nrUXR%hhgCDNcry!$UF4mJolEEoM!)E*50u#&+e!vOuXV6xrSf3q$> zb`xIB zRtAZ}62-Tvu8=E? zv>RoJ9nW(rhULn?(Rh=n75JfdZ54WSuoBrPm!r2EZY5nNOOqBL-O{=-2mq$ldsReJ zCA?J{dH;f5>-&sJZ2@OMX9ur%uAYmfSsDybsblHl-6Lvt>$?xO8sIXjz6M%pL)Vrp z*5=H6N_B(<1m3Ba*SX`hor`fX$b&l3D;KS8a2hM<#tv^h!4pwg>a`A@If`vDgePB^ zci2Aio%17kDAmJPz*ET>dUGLi>TwJm%y9_YbbI}ze@G$mjkz6+)&LpZ6chTsO`d&O zh#Q$ox-RA)$> z6qeJ9>`gT`TCzdn_NJ;CH9Z)=&~&tUBMAFnnmptR9lqk5oJbs|0Q6ic+m5V6+4OG; z+&WWNN-MhDo`5D6sB@s+TIpa@Ym_g~op8*~;)=aa0g|o8l2`zp)7f)v$a|IcaKHVg zf#AXQ(!B}DR%3afD`>hway!6Vpm!#Mly5peWiB=@cHgKVXSeOnH!>;dUwTk{0N8kj z#<^hEGZ$3nnN%5VaP2!$z{){{Uf5ofSm}Nd@+?-}@ER)x43eT=V8acYD&vht8~z_Y z@ULBYZxi@~;C*sPJm$s}@no4q$+Lc1AA8)9W#lZrV)^U91fHQzCYO$o3o*`fy37_6 zPwiIRe95e8t@m`a5M%=soED)EIUZ80vKJ}VL{+MhbuLq+VM+DFM9Th)^~tvWK!0c7RYqAF?9&TCDQ$0}^v z#+w6!%pZ8DGnwVeCR%+ib; z)%kZQBvzn<*@KTV1Oy*HjL@3{jW7&nVHJwNQ6B4Q9+N1P6%-f@kL8<~9Kw9V@=Q*g z9R}@vJv;yy0XB2~1N1Dh_0nCJ4rPkT<3sO+qeIH$Cw4wqh?4E@tU+O4i^qyO-ESW; z#2mwgs?Rjs(?IN;wecdmn6f4k@zL>-$_Rg1*hh!!0y?3l6XXtJ|1$OhlOY8H(0z`3 z0q8n0_5ouqqD%&*FD7v|F6rj`%84}ULR`D1gSva_GQNRAbu9u+nH}|FL zHU!nR4hFgi<(htg|DZU)PRg7t7=~s-Tc}$(wTC4qDU}}?wgxFQRx;&O9>rO5rDdtu znAxPMmw!l!smvXr8;w*QjFn(;fWj(YztsSze$ZpqbYx*ym)E+EjV0N{TKHJ@cwv6p z#f75_mY05Mu>Vii^uyzeB=c#uR2XKLeZeWvl~r%729m>*u$xPk=A6|_+GOmYR>&>J z7O|>VMd>u&Ln-Ox`#vwH&1ED>_~^0u5heGkYBii6oO8efQ7Me?eyQL_;8f2T*Qy7L z6_xQ((&T2Y#6^``mk*G8ixeBA`w_B>M#D(!>|7k1e(ekVujU`Ci9`D7kY@OjiqkEE zdj#avpOyy#WF)!Nuy{>VRQhMQs!7(zDwUsorZ=jZ1KsacavUQj4k{0YkP(d4QqhYJ z<+5UzNOzJTW=xd`pF^AF9G@!pO9-ZxWqBQ&$EF*xl}on1K0fBF$aPYVY2`o{q{H6Y z_6@G?ilgh{UZ#`e#THV3VMqT*lqJQC2|Tps1pKy5e`QX^%c>Y2{(;QN#m`7$-a|>_ zs;%2;Dz}DZ)LD}P=+$yt^K)*H0ZbWpdE`>6#VCz3m0CD!=7P=Qs*Ge_$g`u?NR!^d z$+kmE;AV9j+BB$|!^k9dNHfBv6&*vbb&M5_Ta4LgY=>l3$qhIw^~(<0mrJ{y6{H<5 zM;xdnnG04UztGfFj8g@W!<*K)`u^>W;?LV9Q-A^~0Re-8x@{E-)}e76ZnRd{RUJH< zUD_w3&QO@AGdj^tksUZfsso!}=4PXM#>k$Lup3@%o5qD4xkhlUcY(v+(RCjHc+v*!y_M*zc*3GqRW7B)t^g?U7NF=!} zAg@!NV=^No{5A@qx_E6hoD{diCqkHg-4|x}Yj5CR$M`=_57aO2*`d>iDQ&IW`BzRe zl5svCX4X2K=S7T?Yr4pXq*U1l6Lu9Iu-a#zeB{>cmhZ7HP_~lK2m7NsI;KG?zlsOaHxIL zV_`5{=HxzhG-Q!yC|718Q(CaX;Zug)a*SrC9-gG)?&~Bu&!|LeB6<8YyBv18I!TGl zZT58v2*|T5VRnahh(?Tgy>D??n8!OSGz5>-h)ow~tFC-u(gZ z`tKeJ{1!x=H34aqdjrHBI51F5w}a*998sNArEyk6)8w6wMp!e~x{?oPbyM2x_bTSp z^i* z@*Z+VF0%Kf>)kO^j<;N`mlRY-s9H*(wzQ1S;T(G~R>iK1aY;hwgs0cX9gGw3+Cwwj z|1xa_N`#&F8Edr_iO7z(Vni_;??x7k#VdF`wrY-GaS4x!YhH3<_#@Cnb&q_h7tb znHl5H&u&(@ZLZoo0jm4}2jh~~^41YlHJL;MeR8aE+aOYss94R(^AH9Pi>4@Em9S{m z9Q6Lk6;8vX0;ewDHYfeB-uvg)jMcnA`e~0waj>KR>T3vSiZP8k3eu~#Tc!(QqUOgM zqhn1^wqJfa>_Mm6s%h)J&C(%!g44Bh7epYlO9m#o+NGBzcLJ6AGe+cws|HyiE*c-W z7(1>HY#T%by_7%LDQmZ)k%u)}86>xCAFXd@V~<*MKiqqWH%>X%O7)IK+q)6>ZuU-3 zyB)Y0+=_~P_Al}(-~WX28Mx$MvBu#&VAmJ;@gabajegVjh%AsXhA z!_|#cg6V_HTDF7E(5t2X{0!OWvl`_D)s%VUSbl4QulPwN`-)h=xScqa^y0}W$ zBJAm7Ki*@oWGydbw}NO&Gy^cY(k1~RK+lB;K>>8-%2o{!6x)4`fS5vl!U;jb(Lf)g z1iV>7b!DJ*n(NqWSNJoo;jZkh3ilZhgKGRAVj8d!53iA0Ku}yAj2tJ1!=(nrtfBAr zZE48vp2?Cm%oKAp@-UptmC3twlcmt$Oq1eYU>yD%W(HtwSMx~Xch5n>hD~WPA_TyCxx-O1%2<=0IJm(p0 z#RA79!{I9aaMo06&~as#EtsF@^k@p#pmRh$M`2+~86ezi3Wh0>`FVFo==;;xcDT#q zc>p{)xK3NR50!HOS&)?~-ELI|3+`d9hPIWX7Gr19Uz*c@TKOsex~GV`TLKOa-5hzh zF%img9TJO(0xW;Z;O#D-`GJ9KQL*QK$+$amgW1>!RkykVb>oAws6@l3Bt4mC2dxIe zSt>7fh*EXC6&q%^AeS7L`BjhmptT14ZdVLsv))uzq+1k(g(3qJ2zq`3G)@`EFNb67 z5cU^M{oKkzm23YhBmCp6lFGwq##hK&f28mOAn>2Atx_Hs+DuCH2k}2Xc3CV&gi&D2yxk>-xDDP7ev)G|E(YzmsvoAbAG2EXrhu})$FK9j>cKu&Ey+0m7 z4vug~zM+4WIR5j=_rg&r$_`{><}ZD`r;X|FKXb&02NZRueiOwc#_cx*ck>Jj9dE=y zynXmIm$n3T^4fnWEkL-iNhedQcGj((Zwke6qU?fC_-gk_h}8F)c#4wgVxd+#EsA{i zgd%&GD4yvrsDo4h#t57Ky+1ABkG$hC4lugo8x~ln&+XseXG`1fyyU;=cU z|DP{cJkB@LNc7Vt0do7!#;{HdilJ8v@KFHr|2u%q4(NVWl{dG?c%E9zkP1Ngh8CL` zgVS8h20{1Rk{IWM7MW_mBVl-Ux)%!70{!{YfU_x0wY*3`XgfFJoZn9_reBAJE%jD% z9veSG=Cu7o$O~D?saE4T+~Dte&#K$amn;!QYi4E^{h00ab&h?7aT{lzB@$I*|NByd z|AkCbe*tApz>}*s1)7iM0D0*>XW}-Z)4rKP3Ik>G=#M;UPMZ-z2?#)MmP*hA_JhLc z{}8Y@s{>2k8Vv0@%};sd^1a60PhCFe@Y5|R> zTA-*G5Ee#5?zjN~&S|RJhKE#y(~Ipb7VKH>EV_LBg3;iNrYV zFVHa1ar|yEe!&&`?d^Yl&F}y6@;gH^?bY4!CjGRndyFpRL+X#>F)h%8-sR?21^w$3 z0P+|Bq})&z$)eXQ0N70!aIdp$z(_w_SEbqoEhC$e`Qj05(m+GQ@0nVWVHo|(FMKH8 zbI*;{KyT0tz}2b16j_i$wUkqUQG&8>=>EPf$I%Xy^46_ds5anP z*=nJVdAZQT0XV58m5K~$fP6y$kimEksvs#wsW*V=0E*OFvBEYNs0auE)h&IkR#8#W zK(L8~K|L8ru2A(&>7JTm;fn^#*!J+&+0*fboSJX?%lDAv?&O-1#NX$)QDY-SB|ba-T4j zc=)U?y!nnV`~2o&!ifpY`Bg#o%DJ~LJ~KXNCA#_UzlfFYLDR-{n-6MysR`9m>?}>z z`YfHr%HUF_H$_Wa=n+YHsYUuuyb3{7i1DX@0DK0^x$1(LcjtAfHsS2+`-tOX`{;3t zuA^#)<1xg6VOMn5!uHW2vZ|_>+q4VG6VtE+ga;(12w~O7yE!-`#SHC{91j8M1C=0! zvZORd73j9TyUpvkZXZ%W2&rs>loiP7;js_!N9^|N2J_A2vI)6$R@j zpnUL;UrJqtaKb7cj_w)(eFARm58i@Dt2(@G2ZzV-YVvN@#%yCFXdJ)$$W`yH+`Wfg zT=`wKrVqXWw(S=z#z-pxJHYokEMcUIS=YdqTQ|Y65E-~;slZ}d?sb0Nn+)!};YOaA z?K%~&j6tggvg{i=<2k=9w>B!<=@o?nB?x;KIno4s!0ng< zpcPglJYziDVO@#3qY;EnLn8l}Ak-jQZ-Kyqv~~X1iTg3QYxf~wBP7}uic?2fN|#N2 zxY66?a=cvt8q^I_^7}IsQh=gBu~9z#2>>Q1fljQe{h?*It$n;-dPn+s9y zWgS!rl;B(|I4o45@_B0HaA=Ut1HW12%f0t9`*UU2=LdI`x7(PiBja6G*=$y_ijx70 z(%fkO;NSw_*Z8{`px#D=ru!%+AjI5SgW&fUT}-M0=OYvd|3cTt%kyXWOe!`TS4+C~ z>cnDrxPhdC-4b&0#Mz6@2znNe%MW;ozM}M51a-9S?W5fs7lzLZGvp_>Wnlk7zq~#< zvB?0$I1+%h{yF)6&AB{<(LFPL~*3{wgMy?fDA1tNVaEf90kJ~Lo z(O8SM0VN-Mnox#Oht<3&o_EUO{)QEj>Ez)!-WP4;p}E_su)A{T<~mYN^;kj&X;LJ-iZT{&)fbqzob_nfFH^IL-m+yNdNcvknfh7Gk9@i-~zzpMB zCQS@*TJrZBa+_`{OBt)D=Hy6bWo2RZgHAh|dp2^{c%2=UO3k(0g<^`<9)TYgHPBBg z@{N5Yd5ArNlH1YSoNmCh!al`ep||W-Zc-JNM%?gk+1UOvCgVI(CbZf zy*zrZnMlPkzxzea1Wih0Z#~*FF8aU(*Hr#n5 z!NDnIDUSJ@FFFG;$GOM^e>eZT9Z}rxMmNLI$Ix6G%Dr>q6`MUjKW~^msODf4o3grV z3j#yBMFOEzp4~nfJpiS|+%5eI;92Iwhe)8;u#JGUibb;L>ZT?qC&!nimH-(OC}276 z1u+Ruw!0HXL&Jljn1jBQJnK)NK4BUW{%#NFgZM#w&Jon{=k7fSis;*Y1^5nyL?Z`7P! z0z9(}shrEH3B7%3GC0dv@%PPVn{VRDC@V*R#(}+^9$#mcBe3)DEfYU+26`e^WlPBs zy(zp$OY|-~Jwn8VGQW?BFIE<8&N6@Q?Sik>V{6H!ZND$I7QRQ+BoCrRG8qW(ez};B z+fJwxZKwShC<1+uNn=5j?`sCO#LS;Tf{YXDOEvPYI*ZM>yCu)-dVpg_s>ro>;K!HxAoa1@nH^ZJ#LXFaHBI9^r z*;uJW?6Li5fFpKPE-+8cdwd!2|3+t*&W9UPmk-SugU$>=gP|%XhcY0713lPXfr1_3 zm7VdsuSVG$`ZShOpY87xM@h8bBIz99yqlp;)c!(2A+&10fl0f`QX-nG^qUePVChrc zd|Lt-Xdi(Xgj>*HCHppdYt?oXOtxX&bZzi@tvd+*#MMs@2BAzYh_;WgeyRW>6FY@DP7GFr7Zv(S zo&rLv%zK|Xd?b&Wg?Iu!;L;rvje`>?U*j1$&^@wjBC|={oM|H7$twB^#08*Qp{gM_ zT@E)_ISSM#K|m4+BFK>{B>;c@r^l*!i!*e~xJDTF`R}VH0uds2DtNU&oUfDO>$IwY zY1J>UYiuk5lsp7#^PKnV$ddtse`3jAuPBoing$Sucn(CZ&BO1%e)?pzRys8+tHb97 z3aWmvS6r?7WffSHtX0jM+BZbM?@X*LzRj4JOC!p;rvDt`8Au%C#=%NX3gF))9@8cr z9acR66k7eNfdOhRK-XLb!?RG_U(8(o?UzAf6h2psbakJf!@JquwfPl?X?B}T%XvFuG7-?TrzMDL zWki6psz(Kfm{DvY%0>-kxc11=$!Nf?8C*HN-_!hvjV*b|EK5lmgzxtIQ|{1A#r!hv zuU4R=TCi=sIX2ZF`?nWHLq8(K#~+mB8~=T?wNm4wy?LnJ{ygH5NvC9)9yGZCbR=4~ zP=?N~+_nJ7ImoGlR(+tKhuUO?W2NIN-#xule@m(e-Q(T!?; zz$1?a_vUc2xa*uvpuuKN(N86UN~XZrnq z--by9C8#*75@R!o=&x#p2?kVHk5d!0M+1UXCH2-iTsU9^T;yqrq?KE*(QC{-lTwgSW7Y_+D zxXxE0I!uxQ_vmBb=a8~BeC~OCtXxr!c6s=hxzObVXU2vB% zmlM=zct3QDabC4hU+(+C4YqzLU@szom|iX^Hl6xvC{(^T7<|gh1&PGYH%Fw&x;2$- zhGv;Ly8ehWTPdZKl~-^=onI9f6eJ!Y;cyKM)t?^^Qg{Wp=$9IZ)!SVgK`0l3X$%(9nM{nm{-#*fy`pV!}DG>B9mp>4e9CWvZ<>_||W0X1jvj*VkuxAQYD* zmCLU}Bl}7CpUX-i#RfTV9|1P{-m-pgSy>qi0JLX^&*tpzd33Fhn2eP?;I-CdEL)7f ziCHH&YE!wQx+(7$9v+U}TKd#xrMb}HVQ`GiV`j>um_NN_&MCiw2`KJfW z7v&&B?-79NlCGq3f^-BZK_i@@H#eap^!_IDS7A;Q?r^VSF~h2BJk z-4c)wl#t{>XzCjqcjioedNlDIC@RU8Z8qM3lITSGgX1^6`f3=EK24U9;7E!E$?{V? z=LvDD-L~zAJ4yBIwi~Z%nRY}tLUX@c8{hf*bsTWxb?p&?uy^VKok^$FtQ)^Pg6sm< zR`Z=DR~*L0Ex4ve<4565*e2>q&mtiI2rOFxp!o&FG9?nDCBK;h1z&792Dm^}gVVeRdtdsWV)OD7?xgZ%@YZ^!;E&@#T^2I@tSo_~jGDte% z;l ze0NgK@evXV8b^BRaw-BUtyhQq0jW;d^2!Qywk2>o2ec6;10%EI2=P8;$>XdS`A)fa_V>7Ln4;zuxHde_X_ZfSuIW-7Qs=6mr-s+ms!= zrWpQxx{v9;<)@tRV%L2LK8!hkq@H;B_b};iKZ#w&Y&|-%XsKRfgyYH`5ft&E=Ko&l z+pg$if+j|XE2j_PXZ*gH!&h2e$7IJB$<&8L-ihNyePBnvMn}@5!E5v(J==>@5(a;B z6P3jG;P5U=JP+^l)#gHo-Dp)j)EKUbpwAuOClj$Qb$I2bOO;$?Ab_Z0%wl&IUWQFkXS4~%jmLWx0wo`Q4+MUl#2S1ek88OiNqJcH4dU~z z)6>aovodK-#%f@E7jYry`|=*DEX8Q8UQzJ07#DTX(f;+rzj+_9*C1Ct5~S%6WELI% zkDz>$vXV{SX%P_-`3eRG29o7^K%W*3-Q+doe6r7(to<`YFIB6^-|a_E6q~3cs8|U8 z$5y!b7{Wf6)q7)9mW3jFjli2}L|I8mxKmM=r%hB97 z9Qs0kjd3D_224V7%4>%2lkm##LP1ec^7r&{=-(#pcfav1>y{L_tD};OZ`@1tMbW3z z*F0b1{lE6U1g^&JTewjq(I_fTlP1-fhbTiSQ7TDDXgHeZG@vr1S&>461{p(?p=54C zGB(nzkxG$dtZ(h-bQ14-|M&gg`@h$HzYo9D+3R`s+QWL*UgO@+!DcF9hjKdxIhO0q z%qnn}SKEdEHBT*c=K(zv8XCIF(y}hujp?e2%RXB_hoxh5EO1<{@Rs3t-n&aS$c~dO ze?sS-88Xv$dJGN@LV&%+{Hp4DOD3nMD+S{l;M}0ey7+oHOMUTnJ_H_vV(mH58vPez zQ@XWKDr_dFhv$4JO5enq4SEaLZxdp&kT%`sk)^Bedg*n(y1LqKD4(;HGVO=w{D+1o z7~*_)Mp^LODp7qWBucA|+mV0gL-E-|*hB<4ITv~AG|Lq5{>w3iM&I5fu)SL#*x!D7 zC0nB|Q^3a$6U*F*KSDHYp1`$ zWa(e&r%Dkbq@PnG#Qx~@|AB&7KMQBWmVI`eCV>#5%j!#9BQ(~=e^PkA2*xz~iO(OsnsF>Nj>J1(i+o&AH$pB> zDl7@%fPV%{R_JCg-n7ePIX4eKx&Z%VIB?CqK62h19OxqkSNz<)>@-}Nc8=B>j;_}B zOrpBCul;=Z;QSozd>pi733M`17U#fpw0H2)lBHAVvN(TN7dLM$SqC2<4^0gXKR-Wp zKa#q;m%RoNkH>2O?r0TFe-}qL=Rd1RU@#aO*j=ourniT+EmKR@!;9(7^zvoO;@o|i zUYlLq{Q%j~&W`COt3BTy=i_DV=Dpe7%T-GjE4oKIUy12mWp7pSQEKtoI#^UG$xCB`Z?fD+oJ`OlLEmYLw1h{&|wb+tA@r%z_ajKWvtgWRW)3J7O zwDEGBJNmuR$V?Azo52Hiv}Mj+qkKrl zx@X~fF@0=-QGclC?YI>hq)=sXXxwVnZnh5YURtu=KGt47vN$_O#3qjJZd$S~K3>2e zUXDJFZuV-f?skCX;-%(eBa7SO=4cDBnvJ8K*GmK4+2#=J) zU|&!hMF3P*4K-MCOj~OYEm@l_J}}d9SDoA)VZN@8K1`VL=yeQoafB~e+GAJ8tpN5D z*QG64qDT1S6NeS@17j>9Qc0vgR{P(^7-X32FJufFo~lmAQ*mTWY`L@9;x{F+<&Qm> zzqrI`B%(T=!ltCRi|s}a7uVnP{M#anPRFZL#^|Z}zmt-*za;#B^%|!z)bT{%Od1gh zf6zN@VzNz?@6w+}qm7gPBs@saG3iem6ZXHQKbQ*t4zu7_a|WKFP9YL;U=#vpxc?Sf z|5ZDSPA91oX>5Z27FvJbVx{2;>Lj2fgFqM+TISy16#gu^2qbVpMh#a6Wt`|DGRFCe z1TvXzQvMcQ|1Qx5Ue_-)TnS{5T{IGoOhF#a{}ZC?7Za31A*(a!qXhkDi>_ZxNfM2s z4qBChrvPgjy4yS2TD#~ny&dh{{)PCWlEzzJKZ&m~ull$6`hP`y5h&_39QY4Nda>E! zAL(}g;>AWLQO5}RzuJKPi@xG7CMStXRVUDKG%_8TT@C@>e-vJ0foKY73o23?G#yj~ zHr4iBF}#aM`rV%va$u@HRIQAnKCAQTPR{XiMxAk;sq0>ffsq9WGb zZwC4w%w90?$TFqU8Nfg*|CE8~U~-MhAv!$z@p6bx1$G&gLr@-*Lr@-*L#Pg78#XSh zj5Uez5ahy;@WPk~${@Uu>|x0;NNthF1Q7zpBoP9}L=jdE*oTeIDxy|@v(o=8E0JLh zGmtD=G{#EoKqxDO02xCHgdfIb!AOvB8jFJx{x<{@7`pKPkLj&{Xcp{OYbaRCBrruN z6wDk)W~ApoI(PGn=}81r?>jyJ(XoVIOi2P2uTCQZXJW?FDyFxOjZ2dcTbx>i04h2V}P(hjfqk{;)dX>?r>eNv>BH{1#TloL|%ncE?5{+@? zZ`uF%2?@C^b?|y=3}lq7WO{Cay<)CRw?Aa>$D}{x%6?1#|G7PVzglR4(aL~@#-O4M z>2LA>Usz}~GNcmOltc=^`nLl3`{X1-MD05{e`|ohPe}rWrcOnS$v~OJl}vBKE=!tF-)XA_1fec&mQFM~>GmJyE7_haLKtian<^CraHsG^b!Vz(J9C4iyT)^w7 z!6p_W5yUzHuSUS*Mj=#0F#GP<_vrQU^}g4FHlXG2t*~pcudg#Ak|CN-p{jx508x5$ ztbn3Uz>~gDcC-SHKvajl<76EoY`0-BVCz4eC?J#QI3jH2r@=N1fFWuRgaw#LqT!Gw z0=owR2LBcMgM$eWc0+gZ@D0%xh|tmihCQ>85~8cq3DCMBA|=2;N*E37SR93cbkI4p zI$B>1Rt4N9!Dz7d)aa0IN2JDjQ-f3znF;~j(Xjy8)X4nHxgZ!^ zY}EP>#P}YT)m==}!-MyX&Sjkb_df>U#_zv(wf6CH^j89Nm_%jJm}&%I z2KW!t`+fmzHXMZj+&KP(2a5v{EieW|1$ZQ|#7P7)sC%F`WJCzi4jf*AgCEG^X8Z^N z$*}5Bm5Q)`0)Z>ACVnOB!3v|(U=l!m#2OSdPWlhiB(ka?W`ZhI9U^1{VF@B;gB1dk zg7rhCLr5K_kM@com;l$|fiq}8Y$6{)2j#!D+6Jj+yN(YRN1i>&841|HAxiUzQ z4jr9{8a5F!sy?0;|2D?^fzi|u2M2S2(?ui*NT3ugsso8+_-5g<%2<<-PJx}s81s>#K9u31Vrkt` zTqIT4Z9>_Q-4~Q~*keF-U}$VqRAjaIopk6#(f{LTihi~KL8quwk!Yczw49F4ACoEA zh9-3M?Z=&&KPFRtM!Uw}Yh&0lo-;EXd352rGID5Lg}WeEl#);6mQc;F(UezE?>%A;djXT*Tni~>5W zGV(#Ng9>0L!96m2664CicNEwHHFl4P+8D*d%A+`_3_G9jVAL|$IItm)MHF<8T?Xe9 z^~HwKnAmvV#|MLjZ86}Tfr*M)wG6PwD0F~M&3W1U6RDp$ZM=&VYkp z4CI=@eLNV=3}}K3JEoAe2NoUz!34x$1~|b8rowr1IF+wXBmgx4or-!!q$kr2!8c^V zU~eM(`a6tu|GhriI*koyv^_KdL=AR-&@Qs&*~3Aj1mkpUw5S?5ies~(!PYYrBmIF6 z->t;|8_(`%2Mt~^0JJ58hc;Sb`7RK%f%y>_Fi*G%20w#Ahy6h?5Hb~c7eBx(zYO_> z4A{j=0xKG3haU%nqsD59?Wuw1iZukrG^=4)V9@aRzDKJ7d!xpPe{Z&b;>Tj{1CdCk zQdq7mINf7q6fi+N2^&J;JjTzYLar4s7m#YS1jD5;sPJIOXm1|e0bFoy;X#og6u>~P z?GG@}Wwbun7KlxMhQR}1wZx{=F9@c<3W8h>7GD4_6fqs*MJ$+t&2{uXa$mtVBI*E7 z(us&yKq=ATnL`wsiU&6qU@oYc>d?(rFCvEPtTJzmW^axv+n9Y6)aINDkQX3yeYn z$K>Y?QLrNZ3Ga*eC2`WfsL~pbzZ+&oCX{ZGhT` zb%=U~7nzKQK^j4v4Z^O#&^qJdtbaXz%8tUqii9@U(N$FZSFzf4Ml^_DL6`_fK%107 zS&mH@WEiqVz+HxTAp~n!_jN!wK*R`?1i+y9(0w``0+s}5hyZ(~8IUI?f+vn(cntv( zqM+$f`*0c+bOS7W8blzm`wX}});$msHs%AFS;Ij)p&`JH{CceWQ5aVC=y0(5NN&Nl zBv$v(9CX5f_q~ku27>@~jCyB{2ENcF*@LBle4vt9lS7k%+vADxZ<7<_BVEwjk5N}T z9s*QkFiFR2DolmJz~S%$gzAyph2S+rntp~s#i4s3M$!2Pu!X>*`2GzOhvTNKd*916 zbkdsDCWZ%codqMciTY&0V6njhV40Edjm$IzQ)qvWEWd>x`&B&HN!7pjCJzP?))!{} zlhE1HAG1Wi{lmZLAAWx?7J&lH4|^CPSP10wVgf<8GXJP9U>(4sLU}Yi2@lQ^i3q`C zPy-ZD<><@?5pGZc0`mmfhgfBZXJeJu8G+S8p`k1f2qy{wjtn6~giL^?iLyVCJVJI1 zg#9534;}@2HxPVdHQAVIV-?w$?24m^U|3;Yuo01AhI$x71WOF-0mgv!z#a=5acn4K znCyz|q5U+8bw-E?kQsv%5fxs)MZ<_f2VF)1(L@FJ403E>=fM6@h=0Rj10WoxAt*%9 zd35x?C&-YX6D*Jgf;Z!1)qzBa!SU!WBDKt2>gA}=&|BE#VbTbnL}GEoIAVO4iHr5n|G%A}11l0sl;Wu1o*?Q% zHsMFrfZP=Z9&BOIfOtBjsSr0(kaz}-jZ`g~8m3|q!6B=~MgRuI5P(5ZvXMdrUlrz# zXXpUi5vhPl1D>H$A$ZFPIw#WLK5#3l#>Rq_C#xC@3of&2eaFHYAH_l`EohsK zgxC$W&BhuX0(8Y1(P-PFSnLsu!x}$u;7L3*50L?QNZ_YnPYJ?2D4GK8As&MiFxZFi z?l+X+1D?dIBmEB=4ojCq@CJ{)QI4vP4t2pB#=s4M+whD*=pv8`&IufoK}HY2;NAeE zLsnXyKtrtqp`jN7;&ciLcoOB7!3Kg>@MwV$fN&T-*hXl5Al8An1P#VSgM)|AECmbs zfKvl#2&Mwdfz1Qj9yJfFicB)3!NH^=!6b+T%qFEGQw#FY;N?PlBygIrB{H5C|9u<@ z5t|=55=0MV+mLfdLg6yBbg(4@n+@P4Bp5$}$Bctz1LhVDs$tcE9Z_}QMp&_QJV*#| zlPJKJn7G6ffgcf5kf=oD<$)q3t3d<|a;p@z(TZ$Dj4`o#Ac7GdyWS`s@HN%}8xL_4 zs>jBI2Z*)L#$ykJjmI9x7~W|6Y&`Zj*m%H}1jIQoW#|dKRU|wRTarLnK{^(m9Ow*8 z=)e;r5;3-4|10Y*X^z5&L*p8L$Aw(?mL8WX)B z+)%$H1`?Ja34pUm@I=6NM|_F^u!$jD1{@8N7b=6V5As0=!N}Uf#ty+mSP8ILpi`g{ z4Rrz%m4M_oz+^Z%Mj`+|qe%fw08atUorDGnFf0QM{!WYkKDPXWphOZBHrGIe5vUB` zFeq5QC>j70K!<(NW*8Va4WgAOmVv!_3Z2A6sa^UyBP#MaK;@t~Be*y^REQfAfM6(& zNP+8Az=Nfa)kp2Y*-v#C1i%ob0J%&>@kSsl9R(*KW`f!y0Ac75HiPXcR5Hjqpd)r% z5Tp$itavKW3snb^1`$kfbU|-Q7l8G!1R3A|s zn;Pm4oE~J6(7-)M91El(L2wHLL7@IbiND8^;Los6>OuS1>ncGsjlHZA7~}gfJ@V-3 zICx{mpTATUmL(p-uGqU(|A|)pFHZBKJsJ$qfWVAk)qBG`NWC`){2{G_7@m&oQ>aY< zmZgC@hnM=nHY{v8(;!AlM=T3Whsie(wggbiuyYPvFdDLdVF5rdU~7SNh6B4G2O9`QY>H}d8-NSk$z+yo6VHnUotSP|5? z2ZEDmerSDDP^b&67__+t%^zFYu-JfFXwAXKFdcN62bn^8wXx00q-3kp&SE9O*Bpf;~~Qa&mM9ObgGKtWGAVP2q9t7|qdSM7CTd>X1I1mmM|E{1w8KINpL{LQRH<%M(`!o9-IePcwzkKWW zZw2*VdgnD#Py{gAKvsi-g15LkZg%{WuoGsXA~zOUPhjsuXc$axBt*ePL$VfxBpw`3 zBovXx00|Ec6;y{s#2~OV6bUl7BxH%A5DYTSL5QO6X~<7N8Vi;PGRGk81`PoBf)Gab z6ov=>0&Muk3?vK>7#BnUz@YgM9xMyAn;Emu5FP};FyjwQM+^^aRsvcrV1r_KprT+L z0D~=y@L-u>;{cNr!vhV7jRQ0&h6fsU-1tF9K{^3NXJ}}KFjJO}LIeO^2$B#fAIMk2 zH^@yoq%q+-9aBQk5mE~P!|r1E2Adb~F+3#jkx*c%dbBAQ?L5Ww0W^pFFdC>(I#M5C zU(#US*v?cs=qRuRAg>HlP^Ur=5$Pz1F9FPQ>mcI_)!{l!A5e7=45?#m^ym-@f>BZf zoC4?_@EAziBc%nR5osxqiD>%<4MZ74D*y(vAhQ_mlffnUi5h=TevHpDkRVdWdOjfa zK%^p<1fDGjN6?-?2P*Idiu94eb0Pwnk$;Nu3p@@;b0LOA%Jh}c`< z;i)0+gZKcz@K_KU7)US*jQbE8#A>lYz+%AAfcdaN0P|sJKa3sRJ&@@Pm<)tmKsCeU zVUaMvF9Jyp-Ge&^lSkW1$gl_)5HzF0>O&R_8HRU9P;a+JJcLljR=NKE{2Hqu&szW*&gOSmPV6b(`5TAg>4A`(uK4%b-otRQMGTww*v5|K4pnyl>{W zp#VP>@!$007)WzMRs#Zj@R%H|z0KTRwxD0sU^}zFg9HE9DL*zzv0a})QWGzC8yDuE zZvy{^?8y1$;T9H?Qqg-Etv7FmUyT_{q5fvjzssOxboNQx(bWT(bKIL1eiQWnnxGJ1 z0iy@UBIs|<{QGAVMnxxByqM8|ep$?pt%=w+1MF0SyaHx6pwz?n2>9>UMuVyJ-}yUU z=*QfUbof=j<3)zVAOs@`*h}x(Z1ID*`ltNv)vqQbc&cnd{(f!rfAx1yAbgC@JHT#5 zbmmXj5tOO-Kiq=;B|EUcZ<>S18tedo5IWj3=ji4D;mhv^p9cKAB=&({xYS0!swv7b zfny@}tD5nrSB6$j;NZB68~3Z4J`P~sXkdQ{>hPPHJ!>taBx#~S8t)f`2l&k=efTK+ zQtc+y$oIg$hGXwdoga`QDVdAn{A?GeA2SYA7Jcz7Y{KX2u$40%GLCC}BTSxj<7@b` zq#S!Y=cKw5A-T?LVvqGn1!{J7b*=Gkzww2@sTl5Qcp$aa%1e4jobr(t`5uN}%$&2C;Fo>-f$U-e*Glb{L)MQYLY8XObZ=L=CUZ;IEdE{&gGmt0 zyv3$A<~HYcTiFqXU1wsHt;3d4i1K9L zEB%$zH@=mzZsv(gmFrA=S|R7Nk-lT0dfURso`Y#-P1ja7O%yVfv5ZUZy0u856i(l!C#{=k~qK9UnQ?9RPgEqIghChuF$&YJY_ zX1kmyx6AX6td411*b%?}a^bae2kU0F_j8$REU}oA7M`^xszs}8j&S;s$-FCetU2x= zcv85=n74gXNWik@GEQYfr9%zbeF4P&r0iRt9HNRIOgwn(VzzSAtCib1(ugUMsoq9T zTbAuRd24vK6v}c9^OX#{(ON2g@l*Q6Eu1A9Oq7VNaT>d zc<2B<5~sfW{egW&JSsCLZ=Ea49cart=~DBAdzV_R=2YyN@^ScG>Y|T$o8>#zZg-oy za7ZHi_ra=Ctt+Rc^zNkxL@hm3G)-YC z2SsoC#I?oRg|!#DIa7&cuh#E~#Y-%7q1+eJrXD>#tsv6&)uDvF>F@KblXqX+v@pWx z+r%S>mtLjea!%_O<6FOYC~tCM3fQjHd!r-teCe$0+Dbfq`m+idSTqak!?_%xJoWRg?PYG*6^&I--beok^ zWO&|e-&9mlc_CoY=XLTI%gpUAKBPF5W;rQ_KUilVMiakl;}+5*!|%wOw!3Qe%e8mp zL(eW7*t=&2vDJ1CEmLj7eIM&%E6XcSTt1M0-_|xTVV(PuClghxIzISY5sHE}a_=51 zzhSX&k%pR_$d}1=9TSCZcgb#w!A{CQRt0?NrPdAE+uxWn|CeBZ2?>&7Vu zb(N%%z$Ipv(==Wmj?(Nn8j}-seW&ILC9C(mPd+EU+>!;@3ofx%I%CBW#PfM zoJZPe{#k|3@{(3^L>_ILLj9JzRAjCD8LRa>-733RpE|#`h9|z~!9FFU&2bKEmR_nk z@>nLr!dHE6fw;Kz@tbjbhRbfqPF3Wn+T;JET;jgR0U0f`pt81_MlC;Miy0N`ueh(> zVBx7X+gMV5SCOBVsiZ>-4!7B+EDK!ER9RYhtkZCbTbITCxyr3JJOS}{-kV$*mY7`3aVIBwFjsQv zN{@lBSJt&!F3aw|8F;W_BU3T+la$etCB{$VZ4-sNyPS8K?^aiMRpj8yA9FvhA@rHa zqB^q)Dc0)L>J;nM{BH^)EnlfLMV4Mmvx!<9r-xr)T6TZ_?(WVhN1kbtD|*cnd$$wr zW_UewPAhmkeI@ttV{1KkoHDCOUC>xBv(d)9EpWH_!Gb(*E59S%St}xH7ED`K8F^p8 zDKclzx~I-7=iS|vPHvb(KJzGiKzquS%+=DK*=AOJHJ2|0dG~#)a(}~l@L)i5?2Qvm zLt&R&?m1T_4WBaaz9jkW#S{0vUvC;NK4&nJ!M%c9D;ceKz@WKiolb;v!MF74+2qj6 ztL^9aD>mjcycFohp+f`j_t)9DKDiMLYHwtOo8w0{SklV0R|GYneedLDR z{dL#wAFFlUKRx;7-K+h{E#aAY3$|yUDarJ-a!gKE2-G<^xuWfgQu3GNc6Yz$WgFEC zHqiEDyV$xNG(KTD-2bL&Wb3vUJ}3ID*XD7E8ReZGNN&&Qt9!V$p`FjH`^{cgBktzL zf^|dvU2keG`%b;Ex8!}w3t+o8-cbU`waKilIsyVZ|oi_L#ZR4%e zT5Bq8T%OBHpI+{Kw}rpff`65p z_N^6R!PPkv?mKHS-)d^TUTYj6b1>^xXL-V|mmgKcq8|qd1n>Tske%HXRn%Sikg#rQ zZb1!SgO+_;`qS%fyWg#CFbizCc4kA|PLcOH^^D#V1A!}UX*O-ocRyQkjlX^;dHupU zYI=R48z$+Ai`c{+NiEFd@noYzv*Cl1`iZ?!T zF?(C;@Y7c_*QYRhmyYnuFC`a*HVmKcYIwn=QtRmL)Bd1{I5E2V^mXc|<1&+Z z8}8ifn{Y7in;Dbn5o9^+R(Rs$tJ*;Y2dU*v3;LVSOW_}G`ZWDs)U}h96L^ zkd)hR&fI1xc<0*_(R~t457%66lH{APtRdNQY1*^r754_VWlr{w4N|;z_tDqs;zc=a ze)|qi-QT;-@>a0Z)Z2p#qS_Akb$7qtQ@8Nx!`;T!A096^xTiey_&zOtdWh0XKF-Jx z!)HADx?L?xbrTL{EY&-(bkjtIUAYqa@&oflcNQdOe90(pCA^kwm;D+lz40@Dp2$`e zhW^LN@^3>nDaA!bdkR?V9v6De*}9T9KN?3~Zdz>1WgoUAekGZI?wq;N9wCG+*%=#g ziSIl^xV?GWcT5)dCTq{Pk<}U4dsn{HuS`UI&MCfK4{(ba)0$_b*2wO-zWAy*fgV$5 z5Tb9YyX?MvQq9UqVwtn<9sVTD)K`w17SAoVO-0Z4wduVjm9*Gp2ai7e(0q78m-5@g zW&KM2DLhh#gydzrg65Z0lMXGBk! zCAy@t8z-8x*mkC_F0X^=E?v)<&*F<^U!EMU8`Nx@A7di8Se+EQRhmD0VnM|dkquCs zpc4JWA&gMTU*8?_S!m|faQuBw-6!sq-Anyt7F~_O9TVQ`c#LPtldaSCaHL1;2_-1U z6ffql&s+6`=iGKvJ!WX?Ri%Ml0tpey_Vk(@T*N}#nPI6KPy7s0`rT7L)5TO4J&!Qs z?VP0}e9ttZOn#T}^;z<>;y1)Um0vY$!~Fx{%AvUjbcw5!_zYBbPrH0zaX=ACevsLg zas4=_@mnb)ojLsuC;O>UroPW6zFtt~Fw;!s$-sdVA>Q>XmaV+5a&pGQ{vpTG@Y$KZ zMCFQUgK7hb=}Pm~p6Yt9ZDl;Ip4|Pgf3VGh78~lzG&L5^$@a^xjH+w-QnqzXj`vj4 z=j9(CEo^nn-rws<+kK{r$LDf(mVo*r68^-B8_H$bM&&_L7I`lkHoi}_p!7%5U4gTg{6E)rq0`4)p>^*^U&L(`{Vq(8s0XkB8M1^$M+wkBz0Ee{dS~2T_ice z@vwZpRL9Vjte*R#eHtGv%tR*bxxYO89YR+=AZBC8XmeJs?-LpQdNKBNg{+L+aT z<(5~CK9SG#aO`-yYUU}a1^n-AxhGTx5x*?;J3+U-cq&DAr1QXzj~ApXQs&~rVz@V%5E?f>Enc%caj%h?uCw93dp*#KX%*` zNXF@N^N@Uc=9KkD^BanpbGJF}#AQvmUn6&ecy(cH8`(fdE3Qs{&(>q5zOoOeJR%xq zc;2Tk64ri~U@$HC(M3rP`=xWD99bRo>ZL&CxBD>3!vNPY)zVM0s+|tvM7NS&w z*NVGgZ)t=6VxRM+f|Xti(Orku`8V7vo|nkKc5l1uCDpLUYvV->nHfpD%A$7 z(*$)7P1xJbpBu1z#}tDzL3QPBiB3)PUUak*rFOa&E;uV~@Zet4oENL3s#b+>)lHuE zsA=tz#hdtMZ#=8;Fe2agLD5Mr`jmy!!2eiMGI6Q^Npo}FOL?`5te5d;j?(X&uDRAe z<0J8~$ifuA#dJ5ZFqO)Fk%QsP>u*BORNq@=yI(}a$_;K*f~oZazx zO7aS^61hgPL8o(7Iw?~tPc!Rxn(9oJVMMl_Oc8jbtySp8SHxFNxZC_LKWna5gO4&{ zB*OOn*#aegvDdDxQ+BD|{&4*&#Ye4Zm72UU^POsA^Lxj%maNBHZ#5fyO?FytZu#6I zZtl6QNZL?XLl>z-8m%?x20Xy*le!z zOOg6T<`sDw!BvB|bj@8O4~4yX-nU+Cl6l3dDiPZ*(fwzIti(cVr$j0zZ?O+jnkA92 zI70O(&xe*yt+f{}NoevmJW>(nZ2#$fNc^BYPBt1UEIhZj^^Tn%|tU32*>qyFW9 z*Kk2~jWlmd`K+y%^9OS=3{>6SJy6wpYxkK$KOkq9eSTK>?%9EncUk9`MYmr6D7z=i zNA2z)SFotK&5^`brvmej@5MG-r)?y<)`ZQj`A{b2FShP%v0u8=7h3uqB@g}TdqKNj zr4S$F`V9C5bN`v)%NNt!J^->w{3-{>RJMrn_6cxdVrFl>m8EwbRXnIE@!M1>t;*dB4$_xFqW#R|wbk)lghC7pr*S^-ex#aZhP`^vbm(IB^O}@d1t?*cww<&&er(?Ji z&8;@}g<4RO@)?anoRn0K_-qg1iiaCbe5evp=C7JcA{}pb#BIsSRbTuz@TTBhcWsTT zN6KebUpjq}b6Mlu$5&e%K2!PoOs^O_WLYnlT4Z-jKL6O=*jt;oiRK)MJ!V_HvBc_H zkwW7G>32Gf%9kGDjpk=Q-#3WkUz;lV*!bNZ<868}FYI-xg`CArTpyO&Mt8_19XTj# z@a&xbx73eQ>1#Io6g}UOx5OeS$S*lWJ|m*v#bc|Ah5B3S^+~%q?v};8og>hnCMgxX z!qX&s1v_km&3!U<@WOUSB)VtW1!IAyjnQ>MF&Bzl7bw)WTuI~X@u(BIDebl`D6h!XxYIYk_j#RQp4QqT z&k~ad+w_^@_BYJ0%#n{W2-Tu?_3jO|i7Zik=+<9rFjaAd;4{wXdoJ&E>m?uRZ@;Rw zIDcvHw!dodlnTBh^xS$XFK3DO#KW63l}Y}^b54j{FP#(<*h9R~ zuroI?eR^M>Dqqf3ouNk;Jf!Hp8)LfUl|?y?Iv-2UiF>lh#C?C-zF{l5duxOIXP@{M zShDbXRG_G}{+ihhArg0AFQ7H!znz>Qbz-D^N74H<38j>)Ui)>u+ms_Z?pX^z+~1_T zz2IFkT%f@Pcj0rln%)%7eW|=bdP{Uc%^P*OLUr%=Z|)MW#|D^Rp~am|+?uDfXlT+4 z*ZHffvct?{XS{gCJ1O=0yy=~nxb9cwr-n^D!wh?S^OlaPLw2!wGb7GoXXnyQyc>ce z0@I7^s0*)olG4_`u~>V~fw5BYsk-T<>D(`dopjcYOjPCdke+jzG^4UeGrT$0h5n$+ zXaA?N4Ilc}L{x2D9k%wqlmj*zB&24mn|Hb=OcPyIPaCx zrf+>!LYrbjIrtBsp?h!r?B|o9&*?2@FI8@y;)%ELEWNY7t*+E_730kpCE0FIC3*!v+3`5~F%S+}gdGUi4aVkL;zxBIi@K z?6tnyb7*&@Ql#u+sjBKS5y8B(jn}F-m!|Q&YS>dZ@sq#KQ4YmWTVma_Pw!UFKj>K- z*tmBE^YKv2w>bj`laIbQUsxV`?%=188#dLAn~prTeraY3n4`5mqb-9vt;6W8 zS@~OmJ2dymqlNibo}XB#GPirNN2BNxvD5yYHy>w|g$2npmPK&Wo7o zQ=Ks5sKKVR{zLnYJeM&zkY`b^mC+uk9sVYs5!@tVnsxHx;>NlB7!=XKlAu9O|+(~c1LKb4A)D_1(=ePG5>?>M5)j*AIFdOMh^4YLlO z^Vyc{ay+xv?#!%A4nS(zF@tOFDrv5{m9yk{NjytWC0$K0*&=$uWXnX>XOL6E@Kk{o zd~WQ88U#A1vrfK^`S#{ew%tkX)3IJ>Ob)y; z2{>QArXg)fKCbP~nZSOJ!cNJCg@xv#!W)iK*RQtl{G=w7J~{1{6?H*N=Fy?;uj00g z@7hSJx_#10?Q&AtCFM5r<*sow*GQkLm6BUlBl;| z`m}e#Nn0xkD+7|85A$*KlLS2ySGcj9K*}1D=wWM8ymVDTdHSll$yL!D$Jgm!IJ$0k z&dGIQxhLS0xz0G+Bx?(gQWfMwqBkwMJi*rZvLMq4KKhq~RCcdCC%5o)wNU!1q4_eB z);*`IGtR=N=TtSH9}7*BE8a=^PNdV6(o`quvLyJ#IJq7aII&KD$0+XEQ`MW;h)Jh9 z%;Wj1aG_$}wKzjU$dP?wI%~XE3#e^g9(lRl#bD8e6t!3D+f#}*FIREg9FpCWC{*yw zL676DW5`Ys=TI(^OK5K9OsZv8=8FxdHp8edJdfM&RO@nj?9Y8eip!N%`q-b#fnHR( zHKtRN)hH|3e-clJK0NsP)b~Gc0v1yXYt8<{`%p7_6^v)^*q_Z=))$X!{_saZ4o0$a z?9VekCt*#0-b$~ixN`5IoB5LQZp6xw_K>tzo|E#QcX2=N&A7=Y-Tu_JeZWE>IaqDq zn>5q399p_+tSaxzDHnwI^?g)V(l#rJUTZx6(;)t8lHZyQ*GKX&KP z?7Ww1XQydpH65m1Dz*J!Q=Bw77x!*3fOJSQKKvZ>RL7U4goAhAeWV%`;hN@4r5Y<< zY`I*!Jm`84XKRE03+;_}#g!J&+n2ZdJzU*$#HNy4x7(L3VHY&Ahra;^ww#hW4Gb-+j#^%B)W==)LxSwa6Q@k8!W;^ZJzOP-D-fo^(C+ zk$sBq@C}Cgn~R(;pQ&41{9@z~HT@Z1`}EFt-S=Kk?=04AxAdTT5~!tn%GKRo+JGX> z;&Psp&{E<+?GsXYC+UAKBks)Cx=9HU@++o@D@V<<$PTP8Y3}`5Wr>mnjVgD{rl#xoy=e&LPMi3vSRYemf*2v|i!7 zhTr>W&bN-$1rqxL?imS`ZwL@r^=NkKwB{+-9ahq{nInSSy8@@276`kxFOWHuGEhaD z*-`4SFM*5p6hESVRL1Y4_neUF9V5l}Zk-*-Zy9Mzc-K@)pMEFmb?|)qk%Io9C(L3#&DyK) zeT%f3>Dom)Uq}`2(9Nipa5y5TX1QdS)8|&Ja;{#}pv(>L$sZ$mL>q!4GP}5iw;ebV zP&4s-;`*-Yr~7Ux4s80eZ2P-A4r%?)+ws7lyvf5VMtz7rX6T|1d56 zb@!_nLQkLB>m-G`mJ7iNGdry{+V$Mq5}yIh!3~f7ZG<= zZkgS;*9ps7XDcpRWoIa#LYG}6zW?SVtN8=-uOAUMl_!{by$%X1rs#PnrS zpVyr|=S{furey!JLZ?UtuPeM+j*fd&Jr$zF&P6VN>C#e>$~)tQy}X}i`TBhQ{oC){ z=ugSW+Ou+jfVsH)qgJwAt*fYeZOr9^bKX6Wd#V3zj^6|B75q(6o)w6kYeMQwSb zyOy{{QX#PFR7etoUJ%vyrQ_^|qLRFGQzxlV^G&=2tCcpdmEekCG`g3>;-9&@#!04K zeJ>!r$Duy9O-5OyY1hZjY8X(yMSp@8L4On8$`|ZxBo7eVm#o5Zb12M4;qE&icC^%7W`|o;>Ft zP~T$h?0#rB?=mCZ9V_B{pT6CdXKb*s^5m7*clBQsW-gC3OLi{v5lIdxek0o)Tr#-q z=Eh}m20^8t-F>?yzbtBvY8T1Ye&hQf*WZ&lkZ5T`+^1jtL5j;#*!s9bk6r1uB8^Lt z3OAQGwT;9cTy&Z4B+zj4tsJvy}C)zKX^Wu%(zgW>3*>MeDBWOwq=)8ZX`TA zCTw-|h-8!F?xl^FT<3gS`tEU$biv9`TxoYGy`59Pc^*%y3%p)^G@@7e@^+QJ{^l~Z zz*f0i*N%3SChR_QtTVGBfMS@n`^@vNZ6OPaPK6epc=0swW}aca)}>Y2xWfx(`*$5n z(w}G*aOPX~?85__i&{(G9xrYb4Gjv}zqD-Snz`v+FEyjPs!O_Fe}0`6JN3MQ=ze{v z!`wzqt!Z8@+X*u^q$XSWYbHETuMAIUTnD4FFeNr=NKe1_0v0}ErMo! z+N6)lBjt`&lcP#JJa2d$ikqdHchYK~{Ow7>WtS^FR!G|>h}i^qCndPnv{>EP5@ea2 z;3;8d+?pKJ5nP)%+q^+TJmcxTqkH+P-|zK5wmx`H{u?p7!N+`l;ZMG{d^r?tqOJZ- zcb0~U)ZC(5QQQak_V+ESa&OEujyI0g2#u=dj8&3tOBBrJOJ3~~Z(9+wr_?1WXJuxf z&ccR5NutViffsclGrT;{7s)?#IPA??BUq-|dDD5g$=YxAz2JP~d)k8UR5^ts^5#}H zKcEE7HjR$4FA^EfI<4ux#wnfql+iuE9hbxV1yAvDN{128&niw^|M;a&`>}!a{&dBf z?Z=-93C?{ym)Sg{5Wje@se_0q=kw0abK1jaKlAyRthW@+={;4Tc~7V^GWEP(aINjr|HC9Q+ef^eI@FK_OiAhs|{LT$=EvmdH zJ5a2^wd~ZxI78EQIUz^Rm5hgfw&-*7T?$Pa=Hs{JIUsF<4 zjXNP7Gw_%r(U*RI;}*LY*5tDDt0aaF$FvPDZk;t?ZK--P;BA@zDciRUS#gbLs+2>W zrA`JG>X#b@GFNX;ESewifi8Jn`K!HWkw8=dU4eWJuN!2sCpR*)w2dlbXJter4i9X6 zr7^&iM$sUYM#erue=udbYX&`ef^?OU(R)X9njk?;~XKseHYjEiMzymV*NF~Jqg|3 z)DbvY`*!KU{F1}9&)o!)uF}+`AII4x#UAhtoYK=@o822;+$*W49VOW_S))N&GVNkh z$%)U)KhJpG-Nv87J*Ypcdkvvg&hM$ic0vd}M`L*Y?8=aL>L+lVL!{@LbXmLexz=Ta zXCgx#jcyIdJnMS)p0M3j|DciL63rFvzSk$ui}X(tcbxwK%6#+U<{FoNI=eJCdG^SI z*w)&hCF#D4Bc>1YY-XnC)L*iYTe*0kxBFz~%^{1tuT%bvW3ndHXgmOpX_!1N>4P>I zud;?SEm+bg;jw!%Ui5C?fe#CCE9$J<^(Pu+o~TNqzEIaXo9OF%o5#6U?}|ZT@GX08 zULznB*>QI|yL z-&wi1{F1|aCD|UFh%UFxGT}Q4k1Kh3Dzfh_-MOtfd6rr#PpL0g%R=0W{>BxyFP!|F zpV!EoKC)u_6B$S2&cLWwla3`M=+a+TXGr!oR>YlN<~{GKTkQPaDABV0EnWGpNEre zHH2D)`S6#Pl++L2_29d?q99_n&b$wb*(Vj}FocDj_inbSJxtOyF!iezRlK0LJ?gruK+vq{JeW@7YkWl!oj_h4 zV)JT#^O1qwX2mOPp3al{B6nNpjz-7^pP5ks6$Ei>AJ_2uqNJiP?e8M)am_vO>Z9+% zws#cS4uXTvBgNe21l$^jIT}w6bL?EMv!o*Ytb<9ajVHgp-Uqr?+7j~T>2re?iPdb> z_*CdQW4)q*u3zv-zE8^#H)Dd=BhN`aJGQHdEtn$r-u(`Z==ijr>L}xqnk50NvB+O?FjPcP;4=-3aNLZ+v zwwPPJl&KK4Kc!NcT-Q@Cv{wAo@T~?Dk;FFMt&D-zD>yxqnY|`!rt5y&BJhQmz*Xes zd0~xMF>TQ$>40y4DlD@<<1KwSIXK<``wMYQuWFIw3%BTC_nmi&d+z6L z+qU9XV=DECbYy+qZtBta8IilD1>n}+-?QGn%k^r%`#$@*2`L@NLjmnu7&rgumlx0Znb2>R7etSl!6#u^JW~K1{`_7A|cl3m={?tA<1BEDgH@V%)kb9|^0v2+Eh7d}h9RXmCoo?*pAyrxQD0tURFa zr)ae?zX`pp&PQcMSM4){*2O3H6?!yhJ4T0YJGpV*g?skQt8M+Eo19O%e^t6S zp=5BX)2()w*t!=i<=@q* zyh}Zo@7qj)R0V_fjE^oZUL>nY+6&)Juar>=j`q?vo^#iv=dzRaa;trNo#ZACCr_K2 z{w&0=Og>6+ecHmz$xFx!97;*6x0?yA?4$M^+hr>Ld>@rZ%Pp`Nr@C9sG1hbHz$K~V zJt-e1@nnm9NgrDH@rBh!8EvW$?Q7U`N4G0O_%#oE+8(J>hD{m@9;q%@>ySGt7#wSS z(`(34Cup!gsa$WwraymZ*~w3H59OWNJ}H-!qbTl_^qQWqf7(=^uqP+@-=Ei77n3fqtjcjmM6iZ_1pke+I9u_(_DlE;zZ=z_w+d2>4XKv%wEm#uV5N2~~djXQ>00 z3>1~CUiplaH8<@3!W?mnltpF_mHqf|#7hth%^kTYrYpA2YKO>g!%<-9K z!og9qh8x?2`5p5KjK$C0%T5C{$`*9;^3VE>mnt;*0s~(x!NDQ*9T!SdEk@B$NtH1@LcE~2(#efKp)r;I_{t0y3v+gnRbrW8jh~k_Dq7hhnqcXF5jELHTU|+ zd2?`}&yP(^$mLlJueP5gXNUnP#B|FE0sXZ)Wx7ktNGPh)pKw$ . +@prefix : . @prefix dcterms: . @prefix jazz_am: . @prefix oslc: . -@prefix oslc_kerml: . +@prefix oslc_kerml: . @prefix rdf: . @prefix rdfs: . @prefix xsd: . @@ -74,15 +74,6 @@ :AnnotationShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Annotation ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:source ; @@ -100,6 +91,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Element that is annotated by the annotatingElement of this Annotation."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], :aliasIds, :annotatingElement, :contributor, @@ -150,6 +150,15 @@ :AssociationShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Association ; oslc:property [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:unioningType ; @@ -167,24 +176,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -204,14 +195,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], :aliasIds, :associationEnd, :contributor, @@ -289,24 +289,6 @@ :AssociationStructureShape a oslc:ResourceShape ; oslc:describes oslc_kerml:AssociationStructure ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:target ; @@ -333,6 +315,24 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -343,14 +343,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :associationEnd, :contributor, @@ -428,41 +428,41 @@ :BehaviorShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Behavior ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -473,14 +473,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -560,14 +560,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -578,23 +587,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -605,14 +623,14 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -622,15 +640,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -641,23 +650,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], :aliasIds, :association, :connectorEnd, @@ -753,14 +753,23 @@ :BooleanExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:BooleanExpression ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -771,29 +780,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -804,14 +807,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -822,14 +825,20 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -840,23 +849,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -947,50 +947,50 @@ :ClassShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Class ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -1060,23 +1060,23 @@ :ClassifierShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Classifier ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -1087,14 +1087,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -1173,38 +1173,29 @@ :CollectExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:CollectExpression ; oslc:property [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -1215,14 +1206,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -1233,23 +1233,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -1260,23 +1260,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], :aliasIds, :argument, :behavior, @@ -1504,119 +1504,119 @@ :ConnectorShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Connector ; oslc:property [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:targetFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:targetFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - :aliasIds, - :association, - :connectorEnd, - :contributor, - :created, - :creator, + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + :aliasIds, + :association, + :connectorEnd, + :contributor, + :created, + :creator, :dctype, :declaredName, :declaredShortName, @@ -1706,6 +1706,15 @@ :DataTypeShape a oslc:ResourceShape ; oslc:describes oslc_kerml:DataType ; oslc:property [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:feature ; @@ -1724,32 +1733,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -1819,23 +1819,23 @@ :DependencyShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Dependency ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], :aliasIds, :client, :contributor, @@ -1894,23 +1894,23 @@ oslc:valueType oslc:Resource ; dcterms:description "Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -1959,14 +1959,14 @@ :DisjoiningShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Disjoining ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -1977,14 +1977,14 @@ oslc:valueType oslc:Resource ; dcterms:description "A typeDisjoined that is also an owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -2103,6 +2103,12 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -2112,12 +2118,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], :aliasIds, :condition, :contributor, @@ -2217,29 +2217,32 @@ :EndFeatureMembershipShape a oslc:ResourceShape ; oslc:describes oslc_kerml:EndFeatureMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -2250,23 +2253,20 @@ oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:visibility ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -2324,14 +2324,38 @@ :ExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Expression ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -2342,23 +2366,23 @@ oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -2377,15 +2401,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -2396,38 +2411,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -2517,32 +2517,32 @@ :FeatureChainExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureChainExpression ; oslc:property [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:targetFeature ; - oslc:range oslc_kerml:Feature ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.

."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -2553,65 +2553,68 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:propertyDefinition oslc_kerml:targetFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.

."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -2622,14 +2625,11 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], :aliasIds, :argument, :behavior, @@ -2722,15 +2722,6 @@ :FeatureChainingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureChaining ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_kerml:chainingFeature ; @@ -2739,6 +2730,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature whose values partly determine values of featureChained, as described in Feature::chainingFeature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -2805,23 +2805,23 @@ oslc:valueType oslc:Resource ; dcterms:description "A featureInverted that is also the owningRelatedElement of this FeatureInverting."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -2871,14 +2871,32 @@ :FeatureMembershipShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureMembership ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -2895,32 +2913,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -2978,23 +2978,23 @@ :FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureReferenceExpression ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:name "referent" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:referent ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -3005,14 +3005,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -3022,15 +3031,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -3041,14 +3041,11 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -3059,38 +3056,41 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "referent" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:referent ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -3180,15 +3180,6 @@ :FeatureShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Feature ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_kerml:owningType ; @@ -3198,41 +3189,41 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -3260,7 +3251,16 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - :aliasIds, + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + :aliasIds, :contributor, :created, :creator, @@ -3349,15 +3349,6 @@ :FeatureTypingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureTyping ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_kerml:owningType ; @@ -3366,6 +3357,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; @@ -3376,14 +3376,14 @@ oslc:valueType oslc:Resource ; dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -3443,29 +3443,23 @@ :FeatureValueShape a oslc:ResourceShape ; oslc:describes oslc_kerml:FeatureValue ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "value" ; oslc:occurs oslc:Exactly-one ; @@ -3475,6 +3469,12 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Expression that provides the value of the featureWithValue as its result."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -3534,14 +3534,14 @@ :FeaturingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Featuring ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -3551,15 +3551,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -3569,6 +3560,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -3616,59 +3616,59 @@ :FunctionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Function ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -3676,14 +3676,14 @@ oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -3829,6 +3829,24 @@ :InteractionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Interaction ; oslc:property [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:differencingType ; @@ -3856,32 +3874,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -3892,14 +3892,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], :aliasIds, :associationEnd, :contributor, @@ -3978,15 +3978,6 @@ :IntersectingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Intersecting ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:target ; @@ -3995,6 +3986,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -4052,32 +4052,29 @@ :InvariantShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Invariant ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -4087,24 +4084,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -4115,38 +4094,50 @@ oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -4156,6 +4147,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -4247,50 +4247,32 @@ :InvocationExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:InvocationExpression ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -4301,14 +4283,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -4319,23 +4310,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -4442,23 +4442,23 @@ :ItemFeatureShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ItemFeature ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -4468,15 +4468,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -4487,41 +4478,50 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -4609,23 +4609,14 @@ :ItemFlowEndShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ItemFlowEnd ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -4645,41 +4636,41 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -4689,6 +4680,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -4776,32 +4776,23 @@ :ItemFlowShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ItemFlow ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:targetFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -4812,14 +4803,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -4830,59 +4821,59 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -4892,6 +4883,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "targetFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:targetFeature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], :aliasIds, :association, :behavior, @@ -5052,23 +5052,29 @@ :LiteralBooleanShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralBoolean ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "value" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:value ; + oslc:readOnly false ; + dcterms:description "The Boolean value that is the result of evaluating this LiteralBoolean."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -5079,89 +5085,83 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "value" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:value ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - dcterms:description "The Boolean value that is the result of evaluating this LiteralBoolean."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -5251,50 +5251,41 @@ :LiteralExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralExpression ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -5302,23 +5293,14 @@ oslc:readOnly false ; dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -5329,39 +5311,57 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - :aliasIds, - :behavior, - :contributor, - :created, - :creator, - :dctype, - :declaredName, + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + :aliasIds, + :behavior, + :contributor, + :created, + :creator, + :dctype, + :declaredName, :declaredShortName, :derives, :description, @@ -5444,41 +5444,38 @@ :LiteralInfinityShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralInfinity ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -5489,29 +5486,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -5522,32 +5513,41 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -5637,24 +5637,6 @@ :LiteralIntegerShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralInteger ; oslc:property [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:unioningType ; @@ -5664,38 +5646,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -5706,20 +5682,20 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:value ; - oslc:readOnly false ; - dcterms:description "The Integer value that is the result of evaluating this LiteralInteger."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -5729,6 +5705,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -5739,14 +5724,29 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "value" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:value ; + oslc:readOnly false ; + dcterms:description "The Integer value that is the result of evaluating this LiteralInteger."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -5836,41 +5836,29 @@ :LiteralRationalShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralRational ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "value" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:value ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The value whose rational approximation is the result of evaluating this LiteralRational."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -5890,62 +5878,74 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "value" ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:value ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - dcterms:description "The value whose rational approximation is the result of evaluating this LiteralRational."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -6035,56 +6035,59 @@ :LiteralStringShape a oslc:ResourceShape ; oslc:describes oslc_kerml:LiteralString ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "value" ; oslc:occurs oslc:Exactly-one ; @@ -6092,59 +6095,56 @@ oslc:readOnly false ; dcterms:description "The String value that is the result of evaluating this LiteralString."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -6234,20 +6234,14 @@ :MembershipImportShape a oslc:ResourceShape ; oslc:describes oslc_kerml:MembershipImport ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Membership to be imported."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -6258,14 +6252,20 @@ oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Membership to be imported."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -6325,6 +6325,12 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -6334,12 +6340,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -6401,14 +6401,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -6428,14 +6428,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -6505,6 +6505,21 @@ :MetadataAccessExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:MetadataAccessExpression ; oslc:property [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:importedMembership ; @@ -6532,11 +6547,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -6546,15 +6564,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -6565,14 +6574,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -6583,32 +6592,23 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -6699,23 +6699,32 @@ :MetadataFeatureShape a oslc:ResourceShape ; oslc:describes oslc_kerml:MetadataFeature ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "annotatedElement" ; + oslc:occurs oslc:One-or-many ; + oslc:propertyDefinition oslc_kerml:annotatedElement ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -6735,59 +6744,50 @@ oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_kerml:annotatedElement ; - oslc:range oslc_kerml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], :aliasIds, :annotation, :contributor, @@ -6878,23 +6878,23 @@ :MultiplicityRangeShape a oslc:ResourceShape ; oslc:describes oslc_kerml:MultiplicityRange ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -6905,14 +6905,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -6923,41 +6923,41 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], :aliasIds, :bound, :contributor, @@ -7048,15 +7048,6 @@ :MultiplicityShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Multiplicity ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:unioningType ; @@ -7066,32 +7057,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -7102,23 +7093,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -7224,12 +7224,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -7239,6 +7233,12 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -7347,59 +7347,56 @@ :NullExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:NullExpression ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:parameter ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -7410,14 +7407,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -7428,29 +7434,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -7540,41 +7540,41 @@ :OperatorExpressionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:OperatorExpression ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -7582,68 +7582,68 @@ oslc:readOnly false ; dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], :aliasIds, :argument, :behavior, @@ -7736,6 +7736,15 @@ :OwningMembershipShape a oslc:ResourceShape ; oslc:describes oslc_kerml:OwningMembership ; oslc:property [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:source ; @@ -7750,15 +7759,6 @@ oslc:propertyDefinition oslc_kerml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -7872,14 +7872,20 @@ :ParameterMembershipShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ParameterMembership ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -7890,11 +7896,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -7904,15 +7913,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -7980,32 +7980,38 @@ :PredicateShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Predicate ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -8025,29 +8031,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; - oslc:range oslc_kerml:Feature ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -8119,6 +8119,15 @@ :RedefinitionShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Redefinition ; oslc:property [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_kerml:owningType ; @@ -8136,15 +8145,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; @@ -8207,23 +8207,23 @@ :ReferenceSubsettingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ReferenceSubsetting ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; @@ -8234,14 +8234,14 @@ oslc:valueType oslc:Resource ; dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -8385,6 +8385,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -8400,15 +8409,6 @@ oslc:propertyDefinition oslc_kerml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -8467,12 +8467,6 @@ :ReturnParameterMembershipShape a oslc:ResourceShape ; oslc:describes oslc_kerml:ReturnParameterMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_kerml:owningType ; @@ -8481,15 +8475,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -8507,7 +8492,22 @@ oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -8590,95 +8590,95 @@ oslc:readOnly false ; dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:result ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:result ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], :aliasIds, :argument, :behavior, @@ -8771,6 +8771,15 @@ :SpecializationShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Specialization ; oslc:property [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_kerml:owningType ; @@ -8788,15 +8797,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -8846,23 +8846,14 @@ :StepShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Step ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:differencingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -8873,14 +8864,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:propertyDefinition oslc_kerml:featuringType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -8891,32 +8882,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -8927,14 +8918,23 @@ oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], :aliasIds, :behavior, :contributor, @@ -9023,50 +9023,50 @@ :StructureShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Structure ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:differencingType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -9136,14 +9136,14 @@ :SubclassificationShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Subclassification ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -9154,14 +9154,14 @@ oslc:valueType oslc:Resource ; dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -9214,41 +9214,41 @@ :SubsettingShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Subsetting ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:owningFeature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; + oslc:propertyDefinition oslc_kerml:target ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningFeature" ; + oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; + oslc:propertyDefinition oslc_kerml:source ; oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -9300,23 +9300,41 @@ :SuccessionItemFlowShape a oslc:ResourceShape ; oslc:describes oslc_kerml:SuccessionItemFlow ; oslc:property [ a oslc:Property ; - oslc:name "guardExpression" ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:guardExpression ; - oslc:range oslc_kerml:Expression ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:propertyDefinition oslc_kerml:type ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -9327,14 +9345,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -9345,23 +9372,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:parameter ; - oslc:range oslc_kerml:Feature ; + oslc:propertyDefinition oslc_kerml:source ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -9372,32 +9399,23 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:parameter ; + oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:guardExpression ; + oslc:range oslc_kerml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -9407,24 +9425,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:source ; - oslc:range oslc_kerml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], :aliasIds, :association, :behavior, @@ -9539,23 +9539,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:importedMembership ; - oslc:range oslc_kerml:Membership ; + oslc:propertyDefinition oslc_kerml:target ; + oslc:range oslc_kerml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; + oslc:propertyDefinition oslc_kerml:chainingFeature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -9575,32 +9584,32 @@ oslc:valueType oslc:Resource ; dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:type ; + oslc:propertyDefinition oslc_kerml:unioningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; + oslc:propertyDefinition oslc_kerml:importedMembership ; + oslc:range oslc_kerml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:intersectingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_kerml:owningType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; @@ -9611,41 +9620,32 @@ oslc:valueType oslc:Resource ; dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_kerml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:intersectingType ; oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:target ; - oslc:range oslc_kerml:Element ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:chainingFeature ; + oslc:propertyDefinition oslc_kerml:feature ; oslc:range oslc_kerml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], :aliasIds, :association, :connectorEnd, @@ -9744,12 +9744,6 @@ :TextualRepresentationShape a oslc:ResourceShape ; oslc:describes oslc_kerml:TextualRepresentation ; oslc:property [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:body ; - oslc:readOnly false ; - dcterms:description "The textual representation of the representedElement in the given language."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "annotatedElement" ; oslc:occurs oslc:One-or-many ; oslc:propertyDefinition oslc_kerml:annotatedElement ; @@ -9758,6 +9752,12 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "body" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:body ; + oslc:readOnly false ; + dcterms:description "The textual representation of the representedElement in the given language."^^rdf:XMLLiteral ], :aliasIds, :annotation, :contributor, @@ -9813,24 +9813,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:type ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:featuringType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType. It is the target of the TypeFeaturing."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -9849,6 +9831,24 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:featuringType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType. It is the target of the TypeFeaturing."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:type ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], :aliasIds, :contributor, :created, @@ -9898,6 +9898,15 @@ :TypeShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Type ; oslc:property [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_kerml:feature ; + oslc:range oslc_kerml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:intersectingType ; @@ -9924,15 +9933,6 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_kerml:feature ; - oslc:range oslc_kerml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -10010,15 +10010,6 @@ :UnioningShape a oslc:ResourceShape ; oslc:describes oslc_kerml:Unioning ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_kerml:unioningType ; - oslc:range oslc_kerml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeUnioned, as described in Type::unioningType."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_kerml:source ; @@ -10027,6 +10018,15 @@ oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_kerml:unioningType ; + oslc:range oslc_kerml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Type that partly determines interpretations of typeUnioned, as described in Type::unioningType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; diff --git a/specs/sysml/KerML-Vocabulary-vocab.ttl b/specs/sysml/KerML-Vocabulary-vocab.ttl index 8477c3d..0e6b031 100644 --- a/specs/sysml/KerML-Vocabulary-vocab.ttl +++ b/specs/sysml/KerML-Vocabulary-vocab.ttl @@ -1,14 +1,12 @@ @prefix dcterms: . @prefix oslc_am: . -@prefix oslc_kerml: . +@prefix oslc_kerml: . @prefix owl: . @prefix rdf: . @prefix rdfs: . @prefix vann: . @prefix xsd: . - owl:sameAs - oslc_kerml:AnnotatingElement a rdfs:Class ; rdfs:label "AnnotatingElement" ; rdfs:comment "An AnnotatingElement is an Element that provides additional description of or metadata on some other Element. An AnnotatingElement is either attached to its annotatedElements by Annotation Relationships, or it implicitly annotates its owningNamespace." ; diff --git a/specs/sysml/Resources/genVocabAndShapes.ipynb b/specs/sysml/Resources/genVocabAndShapes.ipynb index 24dd311..dc078e3 100644 --- a/specs/sysml/Resources/genVocabAndShapes.ipynb +++ b/specs/sysml/Resources/genVocabAndShapes.ipynb @@ -14,7 +14,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -25,7 +25,7 @@ "from bs4 import BeautifulSoup\n", "import os\n", "\n", - "genOASIS = False # set to True to generate OASIS SysML instead of OMG\n", + "genOASIS = False # set to True to generate OASIS SysML instead of OMG: Deprecated, only generate OMG\n", "\n", "# use the class name as a prefix to the attribute name to ensure they are unique\n", "# this should no longer be used, but the method to calculate the qualified name is retained.\n", @@ -55,10 +55,10 @@ "vann = Namespace('http://purl.org/vocab/vann/')\n", "oslc = Namespace('http://open-services.net/ns/core#')\n", "oslc_am = Namespace('http://open-services.net/ns/am#')\n", - "oslc_sysml = Namespace('https://www.omg.org/spec/SysML/') # OMG namespace\n", + "oslc_sysml = Namespace('https://www.omg.org/spec/sysml/vocabulary#') # OMG namespace\n", "if genOASIS: oslc_sysml = Namespace('http://open-services.net/ns/sysml#') # OASIS namespace\n", "\n", - "# the OASIS copywrite and license information \n", + "# the OASIS copywrite and license information, not used for OMG \n", "copyright = \"\"\"\n", "# Copyright 2024 OASIS Open\n", "#\n", @@ -79,7 +79,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -195,7 +195,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -216,7 +216,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ @@ -593,16 +593,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 21, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - ")>" + ")>" ] }, - "execution_count": 13, + "execution_count": 21, "metadata": {}, "output_type": "execute_result" } @@ -619,12 +619,12 @@ "oslc_am = Namespace('http://open-services.net/ns/am#')\n", "\n", "g = Graph()\n", - "g.parse('sysml-vocab.ttl')\n" + "g.parse('SysML-Vocabulary-vocab.ttl')\n" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 22, "metadata": {}, "outputs": [ { @@ -635,7 +635,7 @@ "\n", ")>" + ")>" ] }, - "execution_count": 15, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" } @@ -2663,7 +2663,7 @@ "source": [ "# create the KerML vocabulary graph, initially empty\n", "\n", - "oslc_kerml = Namespace('https://www.omg.org/spec/KerML/')\n", + "oslc_kerml = Namespace('https://www.omg.org/spec/kerml/vocabulary#')\n", "\n", "g = Graph()\n", "g.bind('oslc_kerml', oslc_kerml)\n", @@ -2741,16 +2741,16 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ - ")>" + ")>" ] }, - "execution_count": 16, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -2761,7 +2761,7 @@ " \n", "\n", "# create the SysML constraints graph, initially empty\n", - "oslc_kerml_shapes = Namespace('https://www.omg.org/spec/KerML/20250201/shapes/')\n", + "oslc_kerml_shapes = Namespace('https://www.omg.org/spec/kerml/20250201/shapes#')\n", "jazz_am = Namespace('http://jazz.net/ns/dm/linktypes#')\n", "\n", "g = Graph()\n", diff --git a/specs/sysml/Resources/sysml-vocab-full.ttl b/specs/sysml/Resources/sysml-vocab-full.ttl index 4679043..32ce3b6 100644 --- a/specs/sysml/Resources/sysml-vocab-full.ttl +++ b/specs/sysml/Resources/sysml-vocab-full.ttl @@ -32,7 +32,7 @@ oslc_sysmlv2: dcterms:publisher ; dcterms:issued "2022-07-11"^^ ; dcterms:license ; - dcterms:source ; + dcterms:source ; dcterms:isPartOf ; dcterms:hasVersion "WD" ; dcterms:dateCopyrighted "2012-2024" . diff --git a/specs/sysml/Resources/sysml-vocab-hand.ttl b/specs/sysml/Resources/sysml-vocab-hand.ttl index 33c281e..e7c2dff 100644 --- a/specs/sysml/Resources/sysml-vocab-hand.ttl +++ b/specs/sysml/Resources/sysml-vocab-hand.ttl @@ -30,7 +30,7 @@ oslc_sysmlv2: a owl:Ontology ; dcterms:issued "2024-04-25"^^xsd:date ; dcterms:license ; dcterms:publisher ; - dcterms:source ; + dcterms:source ; dcterms:title "OSLC SysML v2 Vocabulary" ; vann:preferredNamespacePrefix "oslc_sysmlv2" . diff --git a/specs/sysml/SysML-Shapes-shapes.ttl b/specs/sysml/SysML-Shapes-shapes.ttl index e31410d..15c629e 100644 --- a/specs/sysml/SysML-Shapes-shapes.ttl +++ b/specs/sysml/SysML-Shapes-shapes.ttl @@ -1,7 +1,7 @@ @prefix dcterms: . @prefix jazz_am: . @prefix oslc: . -@prefix oslc_sysml: . +@prefix oslc_sysml: . @prefix oslc_sysml_shapes: . @prefix rdf: . @prefix rdfs: . @@ -21,59 +21,41 @@ oslc_sysml_shapes: a oslc:ResourceShapeConstraints ; oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AcceptActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "payloadArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:payloadArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the payload parameter of this AcceptActionUsage. If provided, the AcceptActionUsage will only accept a Transfer with exactly this payload."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "receiverArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:receiverArgument ; - oslc:range oslc_sysml:Expression ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the receiver input parameter of this AcceptActionUsage."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -84,23 +66,14 @@ oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -111,23 +84,38 @@ oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -138,29 +126,23 @@ oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:name "receiverArgument" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:receiverArgument ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "An Expression whose result is bound to the receiver input parameter of this AcceptActionUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -168,14 +150,32 @@ oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "payloadArgument" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:payloadArgument ; + oslc:range oslc_sysml:Expression ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "An Expression whose result is bound to the payload parameter of this AcceptActionUsage. If provided, the AcceptActionUsage will only accept a Transfer with exactly this payload."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -300,6 +300,42 @@ oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ActionDefinition ; oslc:property [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConcern" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:parameter ; @@ -308,6 +344,15 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -315,14 +360,14 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -332,15 +377,6 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -351,14 +387,14 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; @@ -369,83 +405,47 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -540,23 +540,29 @@ oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -567,29 +573,14 @@ oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -600,14 +591,20 @@ oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -618,23 +615,23 @@ oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -645,38 +642,41 @@ oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -800,6 +800,15 @@ oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ActorMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ActorMembership ; oslc:property [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:feature ; @@ -808,6 +817,21 @@ oslc_sysml_shapes:ActorMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Exactly-one ; @@ -826,30 +850,6 @@ oslc_sysml_shapes:ActorMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -909,20 +909,23 @@ oslc_sysml_shapes:ActorMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AllocationDefinition ; oslc:property [ a oslc:Property ; - oslc:name "target" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -932,15 +935,6 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -951,14 +945,11 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -968,6 +959,15 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -978,59 +978,65 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -1041,20 +1047,14 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:allocation, oslc_sysml_shapes:associationEnd, @@ -1158,47 +1158,32 @@ oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AllocationUsage ; oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -1209,50 +1194,62 @@ oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -1263,14 +1260,14 @@ oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -1281,38 +1278,41 @@ oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:allocationDefinition, oslc_sysml_shapes:association, @@ -1446,38 +1446,47 @@ oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AnalysisCaseDefinition ; oslc:property [ a oslc:Property ; - oslc:name "resultExpression" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:resultExpression ; - oslc:range oslc_sysml:Expression ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "An Expression used to compute the result of the AnalysisCaseDefinition, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -1488,23 +1497,23 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:action ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -1515,23 +1524,20 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "action" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -1542,11 +1548,14 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -1557,65 +1566,56 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "resultExpression" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:resultExpression ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "An Expression used to compute the result of the AnalysisCaseDefinition, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -1625,15 +1625,6 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "subjectParameter" ; oslc:occurs oslc:Exactly-one ; @@ -1643,6 +1634,15 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:calculation, oslc_sysml_shapes:contributor, @@ -1739,38 +1739,32 @@ oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AnalysisCaseUsage ; oslc:property [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -1781,32 +1775,29 @@ oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -1817,38 +1808,47 @@ oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -1856,23 +1856,23 @@ oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:name "resultExpression" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:resultExpression ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "An Expression used to compute the result of the AnalysisCaseUsage, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -1883,14 +1883,14 @@ oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "resultExpression" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:resultExpression ; - oslc:range oslc_sysml:Expression ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "An Expression used to compute the result of the AnalysisCaseUsage, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -1901,32 +1901,32 @@ oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:analysisCaseDefinition, @@ -2107,15 +2107,6 @@ oslc_sysml_shapes:AnnotatingElementShape a oslc:ResourceShape ; oslc_sysml_shapes:AnnotationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Annotation ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:target ; @@ -2133,9 +2124,18 @@ oslc_sysml_shapes:AnnotationShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Element that is annotated by the annotatingElement of this Annotation."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotatingElement, - oslc_sysml_shapes:contributor, + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + oslc_sysml_shapes:aliasIds, + oslc_sysml_shapes:annotatingElement, + oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, oslc_sysml_shapes:creator, oslc_sysml_shapes:dctype, @@ -2183,47 +2183,50 @@ oslc_sysml_shapes:AnnotationShape a oslc:ResourceShape ; oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AssertConstraintUsage ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -2234,14 +2237,11 @@ oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -2251,15 +2251,6 @@ oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -2270,62 +2261,56 @@ oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -2335,6 +2320,21 @@ oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:assertedConstraint, oslc_sysml_shapes:behavior, @@ -2462,65 +2462,56 @@ oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:AssignmentActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AssignmentActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "referent" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referent ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature whose value is to be set."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -2531,38 +2522,41 @@ oslc_sysml_shapes:AssignmentActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "referent" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:referent ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature whose value is to be set."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -2573,41 +2567,47 @@ oslc_sysml_shapes:AssignmentActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -2733,6 +2733,15 @@ oslc_sysml_shapes:AssignmentActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:AssociationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Association ; oslc:property [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:importedMembership ; @@ -2760,14 +2769,14 @@ oslc_sysml_shapes:AssociationShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -2778,23 +2787,14 @@ oslc_sysml_shapes:AssociationShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:contributor, @@ -2872,14 +2872,14 @@ oslc_sysml_shapes:AssociationShape a oslc:ResourceShape ; oslc_sysml_shapes:AssociationStructureShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AssociationStructure ; oslc:property [ a oslc:Property ; - oslc:name "target" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -2890,14 +2890,14 @@ oslc_sysml_shapes:AssociationStructureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -2908,32 +2908,32 @@ oslc_sysml_shapes:AssociationStructureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:contributor, @@ -3011,32 +3011,14 @@ oslc_sysml_shapes:AssociationStructureShape a oslc:ResourceShape ; oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AttributeDefinition ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -3047,23 +3029,23 @@ oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -3074,47 +3056,47 @@ oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -3125,14 +3107,32 @@ oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -3225,32 +3225,32 @@ oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:AttributeUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:AttributeUsage ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -3261,29 +3261,14 @@ oslc_sysml_shapes:AttributeUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -3294,59 +3279,74 @@ oslc_sysml_shapes:AttributeUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:attributeDefinition, oslc_sysml_shapes:contributor, @@ -3466,14 +3466,14 @@ oslc_sysml_shapes:AttributeUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:BehaviorShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Behavior ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -3484,14 +3484,14 @@ oslc_sysml_shapes:BehaviorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -3589,38 +3589,14 @@ oslc_sysml_shapes:BehaviorShape a oslc:ResourceShape ; oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:BindingConnectorAsUsage ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -3640,32 +3616,32 @@ oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:targetFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -3676,23 +3652,20 @@ oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -3712,32 +3685,59 @@ oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectorEnd, @@ -3864,41 +3864,41 @@ oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:BindingConnectorShape a oslc:ResourceShape ; oslc:describes oslc_sysml:BindingConnector ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -3909,41 +3909,41 @@ oslc_sysml_shapes:BindingConnectorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -3954,23 +3954,23 @@ oslc_sysml_shapes:BindingConnectorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectorEnd, @@ -4066,23 +4066,23 @@ oslc_sysml_shapes:BindingConnectorShape a oslc:ResourceShape ; oslc_sysml_shapes:BooleanExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:BooleanExpression ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -4093,23 +4093,29 @@ oslc_sysml_shapes:BooleanExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -4120,56 +4126,50 @@ oslc_sysml_shapes:BooleanExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -4260,29 +4260,14 @@ oslc_sysml_shapes:BooleanExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:CalculationDefinition ; oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; @@ -4293,23 +4278,29 @@ oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -4329,23 +4320,32 @@ oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -4362,41 +4362,38 @@ oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -4407,20 +4404,23 @@ oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:calculation, oslc_sysml_shapes:contributor, @@ -4517,23 +4517,20 @@ oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:CalculationUsage ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -4544,25 +4541,40 @@ oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; @@ -4571,56 +4583,56 @@ oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -4631,44 +4643,32 @@ oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -4794,23 +4794,32 @@ oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:CaseDefinition ; oslc:property [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -4818,80 +4827,62 @@ oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "subjectParameter" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -4902,50 +4893,41 @@ oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; @@ -4956,35 +4938,53 @@ oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConcern" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + oslc_sysml_shapes:aliasIds, + oslc_sysml_shapes:calculation, + oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, oslc_sysml_shapes:creator, oslc_sysml_shapes:dctype, @@ -5078,32 +5078,23 @@ oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:CaseUsage ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; @@ -5114,83 +5105,98 @@ oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "subjectParameter" ; oslc:occurs oslc:Exactly-one ; @@ -5201,23 +5207,20 @@ oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -5228,35 +5231,32 @@ oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -5383,32 +5383,32 @@ oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ClassShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Class ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -5419,14 +5419,14 @@ oslc_sysml_shapes:ClassShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -5505,14 +5505,14 @@ oslc_sysml_shapes:ClassifierShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -5523,23 +5523,23 @@ oslc_sysml_shapes:ClassifierShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -5618,59 +5618,65 @@ oslc_sysml_shapes:CollectExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -5681,23 +5687,14 @@ oslc_sysml_shapes:CollectExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -5708,11 +5705,14 @@ oslc_sysml_shapes:CollectExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -5805,12 +5805,6 @@ oslc_sysml_shapes:CollectExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:CommentShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Comment ; oslc:property [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:body ; - oslc:readOnly false ; - dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "annotatedElement" ; oslc:occurs oslc:One-or-many ; oslc:propertyDefinition oslc_sysml:annotatedElement ; @@ -5819,6 +5813,12 @@ oslc_sysml_shapes:CommentShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "body" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:body ; + oslc:readOnly false ; + dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:annotation, oslc_sysml_shapes:contributor, @@ -5865,71 +5865,80 @@ oslc_sysml_shapes:CommentShape a oslc:ResourceShape ; oslc_sysml_shapes:ConcernDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConcernDefinition ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:assumedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "stakeholderParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; + oslc:readOnly false ; + dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -5940,32 +5949,41 @@ oslc_sysml_shapes:ConcernDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "requiredConstraint" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -5982,107 +6000,89 @@ oslc_sysml_shapes:ConcernDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "text" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:text ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "stakeholderParameter" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "framedConcern" ; + oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -6178,53 +6178,56 @@ oslc_sysml_shapes:ConcernDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConcernUsage ; oslc:property [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "assumedConstraint" ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "text" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -6235,62 +6238,47 @@ oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:assumedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -6301,14 +6289,20 @@ oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -6319,83 +6313,89 @@ oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "requiredConstraint" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; + oslc:readOnly false ; + dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "text" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:text ; + oslc:readOnly false ; + dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "stakeholderParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:concernDefinition, @@ -6523,32 +6523,14 @@ oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConjugatedPortDefinition ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "originalPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:originalPortDefinition ; - oslc:range oslc_sysml:PortDefinition ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The original PortDefinition for this ConjugatedPortDefinition, which is the owningNamespace of the ConjugatedPortDefinition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -6556,68 +6538,68 @@ oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -6634,23 +6616,50 @@ oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "originalPortDefinition" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:originalPortDefinition ; + oslc:range oslc_sysml:PortDefinition ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The original PortDefinition for this ConjugatedPortDefinition, which is the owningNamespace of the ConjugatedPortDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "conjugatedPortDefinition" ; oslc:occurs oslc:Zero-or-one ; @@ -6660,15 +6669,6 @@ oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The that is conjugate to this PortDefinition.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -6763,23 +6763,14 @@ oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:ConjugatedPortTypingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConjugatedPortTyping ; oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "portDefinition" ; oslc:occurs oslc:Exactly-one ; @@ -6790,14 +6781,14 @@ oslc_sysml_shapes:ConjugatedPortTypingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The originalPortDefinition of the conjugatedPortDefinition of this ConjugatedPortTyping."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "owningFeature" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "conjugatedPortDefinition" ; oslc:occurs oslc:Exactly-one ; @@ -6808,23 +6799,32 @@ oslc_sysml_shapes:ConjugatedPortTypingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The type of this ConjugatedPortTyping considered as a FeatureTyping, which must be a ConjugatedPortDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -6875,14 +6875,14 @@ oslc_sysml_shapes:ConjugatedPortTypingShape a oslc:ResourceShape ; oslc_sysml_shapes:ConjugationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Conjugation ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -6893,14 +6893,14 @@ oslc_sysml_shapes:ConjugationShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:conjugatedType, oslc_sysml_shapes:contributor, @@ -6950,23 +6950,29 @@ oslc_sysml_shapes:ConjugationShape a oslc:ResourceShape ; oslc_sysml_shapes:ConnectionDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConnectionDefinition ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -6977,65 +6983,50 @@ oslc_sysml_shapes:ConnectionDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -7043,59 +7034,68 @@ oslc_sysml_shapes:ConnectionDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:connectionEnd, @@ -7207,29 +7207,20 @@ oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -7240,41 +7231,38 @@ oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -7285,14 +7273,14 @@ oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -7303,56 +7291,68 @@ oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectionDefinition, @@ -7485,23 +7485,20 @@ oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ConnectorAsUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConnectorAsUsage ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -7512,86 +7509,86 @@ oslc_sysml_shapes:ConnectorAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -7602,38 +7599,41 @@ oslc_sysml_shapes:ConnectorAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectorEnd, @@ -7760,32 +7760,14 @@ oslc_sysml_shapes:ConnectorAsUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Connector ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -7796,32 +7778,23 @@ oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -7841,14 +7814,14 @@ oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -7859,14 +7832,41 @@ oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectorEnd, @@ -7962,38 +7962,14 @@ oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConstraintDefinition ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -8003,6 +7979,12 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -8012,15 +7994,6 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -8031,20 +8004,14 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -8055,29 +8022,32 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -8087,6 +8057,21 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; @@ -8097,23 +8082,38 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -8209,35 +8209,41 @@ oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ConstraintUsage ; oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -8248,20 +8254,23 @@ oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -8272,14 +8281,26 @@ oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -8290,77 +8311,56 @@ oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:constraintDefinition, @@ -8486,23 +8486,11 @@ oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ControlNode ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -8510,50 +8498,50 @@ oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -8564,14 +8552,14 @@ oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -8582,38 +8570,50 @@ oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -8746,23 +8746,23 @@ oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; oslc_sysml_shapes:DataTypeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:DataType ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -8773,23 +8773,23 @@ oslc_sysml_shapes:DataTypeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -8859,83 +8859,77 @@ oslc_sysml_shapes:DataTypeShape a oslc:ResourceShape ; oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:DecisionNode ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -8952,14 +8946,14 @@ oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -8969,6 +8963,15 @@ oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -8979,23 +8982,20 @@ oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -9119,41 +9119,47 @@ oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; oslc_sysml_shapes:DefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Definition ; oslc:property [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -9164,83 +9170,77 @@ oslc_sysml_shapes:DefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -9333,23 +9333,23 @@ oslc_sysml_shapes:DefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:DependencyShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Dependency ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:client, oslc_sysml_shapes:contributor, @@ -9399,15 +9399,6 @@ oslc_sysml_shapes:DependencyShape a oslc:ResourceShape ; oslc_sysml_shapes:DifferencingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Differencing ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:source ; @@ -9416,6 +9407,15 @@ oslc_sysml_shapes:DifferencingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -9473,6 +9473,15 @@ oslc_sysml_shapes:DifferencingShape a oslc:ResourceShape ; oslc_sysml_shapes:DisjoiningShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Disjoining ; oslc:property [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "A typeDisjoined that is also an owningRelatedElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:source ; @@ -9490,15 +9499,6 @@ oslc_sysml_shapes:DisjoiningShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A typeDisjoined that is also an owningRelatedElement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -9548,12 +9548,6 @@ oslc_sysml_shapes:DisjoiningShape a oslc:ResourceShape ; oslc_sysml_shapes:DocumentationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Documentation ; oslc:property [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:body ; - oslc:readOnly false ; - dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "annotatedElement" ; oslc:occurs oslc:One-or-many ; oslc:propertyDefinition oslc_sysml:annotatedElement ; @@ -9562,6 +9556,12 @@ oslc_sysml_shapes:DocumentationShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "body" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:body ; + oslc:readOnly false ; + dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:annotation, oslc_sysml_shapes:contributor, @@ -9609,12 +9609,6 @@ oslc_sysml_shapes:DocumentationShape a oslc:ResourceShape ; oslc_sysml_shapes:ElementFilterMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ElementFilterMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:source ; @@ -9632,6 +9626,12 @@ oslc_sysml_shapes:ElementFilterMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:condition, oslc_sysml_shapes:contributor, @@ -9731,20 +9731,23 @@ oslc_sysml_shapes:ElementShape a oslc:ResourceShape ; oslc_sysml_shapes:EndFeatureMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:EndFeatureMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -9754,15 +9757,6 @@ oslc_sysml_shapes:EndFeatureMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -9773,14 +9767,20 @@ oslc_sysml_shapes:EndFeatureMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -9838,23 +9838,41 @@ oslc_sysml_shapes:EndFeatureMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:EnumerationDefinition ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -9865,14 +9883,20 @@ oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -9883,23 +9907,32 @@ oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -9918,24 +9951,6 @@ oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -9945,21 +9960,6 @@ oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -10053,29 +10053,41 @@ oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:EnumerationUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:EnumerationUsage ; oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -10086,68 +10098,59 @@ oslc_sysml_shapes:EnumerationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -10158,23 +10161,20 @@ oslc_sysml_shapes:EnumerationUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:attributeDefinition, oslc_sysml_shapes:contributor, @@ -10295,14 +10295,14 @@ oslc_sysml_shapes:EnumerationUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:EventOccurrenceUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:EventOccurrenceUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -10313,29 +10313,23 @@ oslc_sysml_shapes:EventOccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -10352,77 +10346,83 @@ oslc_sysml_shapes:EventOccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -10545,47 +10545,41 @@ oslc_sysml_shapes:EventOccurrenceUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ExhibitStateUsage ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:name "doAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:doAction ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -10604,6 +10598,15 @@ oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -10611,83 +10614,80 @@ oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isParallel" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "doAction" ; + oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:doAction ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:name "isParallel" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isParallel ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "entryAction" ; oslc:occurs oslc:Zero-or-one ; @@ -10698,23 +10698,23 @@ oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "exitAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:exitAction ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -10842,15 +10842,6 @@ oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ExposeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Expose ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:target ; @@ -10865,6 +10856,15 @@ oslc_sysml_shapes:ExposeShape a oslc:ResourceShape ; oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -10916,92 +10916,83 @@ oslc_sysml_shapes:ExposeShape a oslc:ResourceShape ; oslc_sysml_shapes:ExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Expression ; oslc:property [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -11012,14 +11003,23 @@ oslc_sysml_shapes:ExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -11109,23 +11109,23 @@ oslc_sysml_shapes:ExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureChainExpression ; oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -11136,11 +11136,32 @@ oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "targetFeature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.

."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -11151,23 +11172,23 @@ oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -11178,50 +11199,29 @@ oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.

."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -11314,6 +11314,15 @@ oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureChainingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureChaining ; oslc:property [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:chainingFeature ; @@ -11331,15 +11340,6 @@ oslc_sysml_shapes:FeatureChainingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -11397,23 +11397,23 @@ oslc_sysml_shapes:FeatureInvertingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "A featureInverted that is also the owningRelatedElement of this FeatureInverting."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -11463,14 +11463,23 @@ oslc_sysml_shapes:FeatureInvertingShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureMembership ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -11478,41 +11487,32 @@ oslc_sysml_shapes:FeatureMembershipShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "feature" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -11570,15 +11570,6 @@ oslc_sysml_shapes:FeatureMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureReferenceExpression ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -11588,32 +11579,14 @@ oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -11633,32 +11606,32 @@ oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -11674,6 +11647,15 @@ oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "referent" ; oslc:occurs oslc:Exactly-one ; @@ -11683,6 +11665,24 @@ oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -11772,33 +11772,6 @@ oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Feature ; oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:feature ; @@ -11808,14 +11781,14 @@ oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -11834,6 +11807,24 @@ oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -11844,14 +11835,23 @@ oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -11941,15 +11941,6 @@ oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureTypingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureTyping ; oslc:property [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -11959,14 +11950,14 @@ oslc_sysml_shapes:FeatureTypingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -11977,14 +11968,23 @@ oslc_sysml_shapes:FeatureTypingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningFeature" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -12035,15 +12035,6 @@ oslc_sysml_shapes:FeatureTypingShape a oslc:ResourceShape ; oslc_sysml_shapes:FeatureValueShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FeatureValue ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "value" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:value ; @@ -12053,20 +12044,29 @@ oslc_sysml_shapes:FeatureValueShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Expression that provides the value of the featureWithValue as its result."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -12126,23 +12126,23 @@ oslc_sysml_shapes:FeatureValueShape a oslc:ResourceShape ; oslc_sysml_shapes:FeaturingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Featuring ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -12153,14 +12153,14 @@ oslc_sysml_shapes:FeaturingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -12208,134 +12208,128 @@ oslc_sysml_shapes:FeaturingShape a oslc:ResourceShape ; oslc_sysml_shapes:FlowConnectionDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FlowConnectionDefinition ; oslc:property [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "action" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:action ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -12346,32 +12340,38 @@ oslc_sysml_shapes:FlowConnectionDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:connectionEnd, @@ -12475,23 +12475,20 @@ oslc_sysml_shapes:FlowConnectionDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:FlowConnectionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FlowConnectionUsage ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -12502,41 +12499,41 @@ oslc_sysml_shapes:FlowConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -12547,98 +12544,101 @@ oslc_sysml_shapes:FlowConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, @@ -12780,14 +12780,23 @@ oslc_sysml_shapes:FlowConnectionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ForLoopActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -12798,47 +12807,53 @@ oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -12849,23 +12864,14 @@ oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -12876,47 +12882,41 @@ oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -13043,23 +13043,20 @@ oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ForkNode ; oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -13070,41 +13067,47 @@ oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -13114,15 +13117,6 @@ oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -13133,20 +13127,23 @@ oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -13157,29 +13154,32 @@ oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -13303,29 +13303,32 @@ oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:FramedConcernMembership ; oslc:property [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -13335,15 +13338,6 @@ oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "kind" ; oslc:occurs oslc:Exactly-one ; @@ -13351,14 +13345,20 @@ oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsage that is the ownedConstraint of this FramedConcernMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Exactly-one ; @@ -13369,14 +13369,14 @@ oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsage that is the ownedConstraint of this FramedConcernMembership."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -13436,23 +13436,11 @@ oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:FunctionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Function ; oslc:property [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -13472,38 +13460,50 @@ oslc_sysml_shapes:FunctionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -13575,23 +13575,14 @@ oslc_sysml_shapes:FunctionShape a oslc:ResourceShape ; oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:IfActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -13602,32 +13593,23 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -13635,23 +13617,14 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -13661,12 +13634,6 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -13685,6 +13652,21 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -13695,14 +13677,14 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -13712,8 +13694,26 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + oslc_sysml_shapes:actionDefinition, + oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -13838,11 +13838,14 @@ oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ImportShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Import ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -13853,14 +13856,11 @@ oslc_sysml_shapes:ImportShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -13912,44 +13912,32 @@ oslc_sysml_shapes:ImportShape a oslc:ResourceShape ; oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:IncludeUseCaseUsage ; oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "includedUseCase" ; oslc:occurs oslc:Zero-or-many ; @@ -13960,86 +13948,80 @@ oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -14050,14 +14032,14 @@ oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -14067,6 +14049,30 @@ oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -14077,14 +14083,14 @@ oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -14094,12 +14100,6 @@ oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -14239,32 +14239,32 @@ oslc_sysml_shapes:InteractionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -14275,32 +14275,32 @@ oslc_sysml_shapes:InteractionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:contributor, @@ -14379,41 +14379,32 @@ oslc_sysml_shapes:InteractionShape a oslc:ResourceShape ; oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:InterfaceDefinition ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -14424,14 +14415,14 @@ oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -14442,29 +14433,38 @@ oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -14472,23 +14472,23 @@ oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -14499,14 +14499,14 @@ oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -14517,14 +14517,14 @@ oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:associationEnd, oslc_sysml_shapes:connectionEnd, @@ -14633,15 +14633,6 @@ oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -14661,11 +14652,14 @@ oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -14676,14 +14670,14 @@ oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -14694,95 +14688,101 @@ oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectionDefinition, @@ -14916,15 +14916,6 @@ oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:IntersectingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Intersecting ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:intersectingType ; @@ -14933,6 +14924,15 @@ oslc_sysml_shapes:IntersectingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -14990,77 +14990,65 @@ oslc_sysml_shapes:IntersectingShape a oslc:ResourceShape ; oslc_sysml_shapes:InvariantShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Invariant ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -15071,29 +15059,41 @@ oslc_sysml_shapes:InvariantShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -15185,23 +15185,23 @@ oslc_sysml_shapes:InvariantShape a oslc:ResourceShape ; oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:InvocationExpression ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -15212,20 +15212,23 @@ oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -15235,6 +15238,15 @@ oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -15254,32 +15266,14 @@ oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -15289,6 +15283,12 @@ oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -15380,14 +15380,32 @@ oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ItemDefinition ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -15398,20 +15416,23 @@ oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "ownedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -15422,32 +15443,23 @@ oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; @@ -15458,32 +15470,20 @@ oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -15494,20 +15494,20 @@ oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -15610,77 +15610,77 @@ oslc_sysml_shapes:ItemFeatureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -15768,32 +15768,32 @@ oslc_sysml_shapes:ItemFeatureShape a oslc:ResourceShape ; oslc_sysml_shapes:ItemFlowEndShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ItemFlowEnd ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -15813,14 +15813,14 @@ oslc_sysml_shapes:ItemFlowEndShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -15831,23 +15831,23 @@ oslc_sysml_shapes:ItemFlowEndShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -15935,59 +15935,59 @@ oslc_sysml_shapes:ItemFlowEndShape a oslc:ResourceShape ; oslc_sysml_shapes:ItemFlowShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ItemFlow ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -15998,59 +15998,59 @@ oslc_sysml_shapes:ItemFlowShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:behavior, @@ -16153,23 +16153,38 @@ oslc_sysml_shapes:ItemFlowShape a oslc:ResourceShape ; oslc_sysml_shapes:ItemUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ItemUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -16180,107 +16195,92 @@ oslc_sysml_shapes:ItemUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -16403,14 +16403,23 @@ oslc_sysml_shapes:ItemUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:JoinNodeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:JoinNode ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -16421,68 +16430,59 @@ oslc_sysml_shapes:JoinNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -16490,38 +16490,29 @@ oslc_sysml_shapes:JoinNodeShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -16532,14 +16523,23 @@ oslc_sysml_shapes:JoinNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -16730,14 +16730,14 @@ oslc_sysml_shapes:LifeClassShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -16748,23 +16748,23 @@ oslc_sysml_shapes:LifeClassShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -16834,59 +16834,50 @@ oslc_sysml_shapes:LifeClassShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralBooleanShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralBoolean ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -16897,14 +16888,14 @@ oslc_sysml_shapes:LiteralBooleanShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "value" ; oslc:occurs oslc:Exactly-one ; @@ -16912,32 +16903,41 @@ oslc_sysml_shapes:LiteralBooleanShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "The Boolean value that is the result of evaluating this LiteralBoolean."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -17033,14 +17033,14 @@ oslc_sysml_shapes:LiteralBooleanShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralExpression ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -17060,83 +17060,83 @@ oslc_sysml_shapes:LiteralExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -17226,110 +17226,110 @@ oslc_sysml_shapes:LiteralExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralInfinityShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralInfinity ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -17419,29 +17419,23 @@ oslc_sysml_shapes:LiteralInfinityShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralInteger ; oslc:property [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The Integer value that is the result of evaluating this LiteralInteger."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -17451,15 +17445,6 @@ oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -17470,23 +17455,23 @@ oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -17497,38 +17482,53 @@ oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "value" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:value ; + oslc:readOnly false ; + dcterms:description "The Integer value that is the result of evaluating this LiteralInteger."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -17618,14 +17618,20 @@ oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralRationalShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralRational ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -17636,29 +17642,14 @@ oslc_sysml_shapes:LiteralRationalShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The value whose rational approximation is the result of evaluating this LiteralRational."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -17669,56 +17660,65 @@ oslc_sysml_shapes:LiteralRationalShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "value" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:value ; + oslc:readOnly false ; + dcterms:description "The value whose rational approximation is the result of evaluating this LiteralRational."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -17817,6 +17817,24 @@ oslc_sysml_shapes:LiteralRationalShape a oslc:ResourceShape ; oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LiteralString ; oslc:property [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:type ; @@ -17826,14 +17844,14 @@ oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -17844,23 +17862,23 @@ oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -17871,14 +17889,14 @@ oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -17886,47 +17904,29 @@ oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "value" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:value ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The String value that is the result of evaluating this LiteralString."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The String value that is the result of evaluating this LiteralString."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -18016,6 +18016,15 @@ oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; oslc_sysml_shapes:LoopActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:LoopActionUsage ; oslc:property [ a oslc:Property ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:parameter ; @@ -18025,23 +18034,32 @@ oslc_sysml_shapes:LoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -18052,59 +18070,53 @@ oslc_sysml_shapes:LoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -18115,44 +18127,32 @@ oslc_sysml_shapes:LoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -18294,6 +18294,12 @@ oslc_sysml_shapes:MembershipExposeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -18303,12 +18309,6 @@ oslc_sysml_shapes:MembershipExposeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -18360,14 +18360,14 @@ oslc_sysml_shapes:MembershipExposeShape a oslc:ResourceShape ; oslc_sysml_shapes:MembershipImportShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MembershipImport ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -18375,14 +18375,14 @@ oslc_sysml_shapes:MembershipImportShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Exactly-one ; @@ -18451,12 +18451,6 @@ oslc_sysml_shapes:MembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -18466,6 +18460,12 @@ oslc_sysml_shapes:MembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -18518,6 +18518,15 @@ oslc_sysml_shapes:MembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MergeNode ; oslc:property [ a oslc:Property ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:directedUsage ; @@ -18536,32 +18545,14 @@ oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -18572,29 +18563,23 @@ oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -18605,23 +18590,38 @@ oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -18632,14 +18632,14 @@ oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -18778,32 +18778,23 @@ oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; oslc_sysml_shapes:MetaclassShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Metaclass ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -18814,14 +18805,23 @@ oslc_sysml_shapes:MetaclassShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -18891,65 +18891,65 @@ oslc_sysml_shapes:MetaclassShape a oslc:ResourceShape ; oslc_sysml_shapes:MetadataAccessExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MetadataAccessExpression ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -18960,41 +18960,41 @@ oslc_sysml_shapes:MetadataAccessExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -19085,29 +19085,41 @@ oslc_sysml_shapes:MetadataAccessExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:MetadataDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MetadataDefinition ; oslc:property [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -19115,86 +19127,83 @@ oslc_sysml_shapes:MetadataDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -19204,15 +19213,6 @@ oslc_sysml_shapes:MetadataDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -19306,41 +19306,59 @@ oslc_sysml_shapes:MetadataDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:MetadataFeatureShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MetadataFeature ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "annotatedElement" ; + oslc:occurs oslc:One-or-many ; + oslc:propertyDefinition oslc_sysml:annotatedElement ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -19368,15 +19386,6 @@ oslc_sysml_shapes:MetadataFeatureShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -19386,15 +19395,6 @@ oslc_sysml_shapes:MetadataFeatureShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:annotation, oslc_sysml_shapes:contributor, @@ -19485,56 +19485,50 @@ oslc_sysml_shapes:MetadataFeatureShape a oslc:ResourceShape ; oslc_sysml_shapes:MetadataUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MetadataUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "annotatedElement" ; oslc:occurs oslc:One-or-many ; @@ -19545,65 +19539,74 @@ oslc_sysml_shapes:MetadataUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -19614,14 +19617,11 @@ oslc_sysml_shapes:MetadataUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:annotation, oslc_sysml_shapes:contributor, @@ -19748,41 +19748,14 @@ oslc_sysml_shapes:MetadataUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:MultiplicityRangeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:MultiplicityRange ; oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -19810,6 +19783,24 @@ oslc_sysml_shapes:MultiplicityRangeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -19820,14 +19811,23 @@ oslc_sysml_shapes:MultiplicityRangeShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:bound, oslc_sysml_shapes:contributor, @@ -19918,32 +19918,23 @@ oslc_sysml_shapes:MultiplicityRangeShape a oslc:ResourceShape ; oslc_sysml_shapes:MultiplicityShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Multiplicity ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -19954,32 +19945,32 @@ oslc_sysml_shapes:MultiplicityShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -19989,6 +19980,15 @@ oslc_sysml_shapes:MultiplicityShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -20086,6 +20086,15 @@ oslc_sysml_shapes:MultiplicityShape a oslc:ResourceShape ; oslc_sysml_shapes:NamespaceExposeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:NamespaceExpose ; oslc:property [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:visibility ; @@ -20100,15 +20109,6 @@ oslc_sysml_shapes:NamespaceExposeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -20292,32 +20292,32 @@ oslc_sysml_shapes:NamespaceShape a oslc:ResourceShape ; oslc_sysml_shapes:NullExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:NullExpression ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -20328,50 +20328,50 @@ oslc_sysml_shapes:NullExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -20379,23 +20379,23 @@ oslc_sysml_shapes:NullExpressionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -20494,29 +20494,29 @@ oslc_sysml_shapes:ObjectiveMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -20527,14 +20527,14 @@ oslc_sysml_shapes:ObjectiveMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "owningType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -20593,14 +20593,29 @@ oslc_sysml_shapes:ObjectiveMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:OccurrenceDefinition ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -20611,14 +20626,29 @@ oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -20647,44 +20677,23 @@ oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -20694,15 +20703,6 @@ oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -20713,14 +20713,14 @@ oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -20814,15 +20814,6 @@ oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:OccurrenceUsage ; oslc:property [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:chainingFeature ; @@ -20832,23 +20823,44 @@ oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -20859,35 +20871,23 @@ oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -20898,32 +20898,23 @@ oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -20934,14 +20925,23 @@ oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -21063,41 +21063,32 @@ oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:OperatorExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:OperatorExpression ; oslc:property [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -21108,29 +21099,38 @@ oslc_sysml_shapes:OperatorExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -21141,32 +21141,32 @@ oslc_sysml_shapes:OperatorExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -21395,11 +21395,14 @@ oslc_sysml_shapes:PackageShape a oslc:ResourceShape ; oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ParameterMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -21409,15 +21412,6 @@ oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -21428,14 +21422,14 @@ oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Exactly-one ; @@ -21445,6 +21439,12 @@ oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -21503,15 +21503,6 @@ oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PartDefinition ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:intersectingType ; @@ -21521,29 +21512,29 @@ oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -21563,56 +21554,56 @@ oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; @@ -21623,14 +21614,23 @@ oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -21724,29 +21724,32 @@ oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PartUsage ; oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -21754,23 +21757,29 @@ oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -21781,32 +21790,32 @@ oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -21817,41 +21826,32 @@ oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -21975,14 +21975,23 @@ oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:PerformActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PerformActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -21993,74 +22002,68 @@ oslc_sysml_shapes:PerformActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -22068,50 +22071,47 @@ oslc_sysml_shapes:PerformActionUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -22237,6 +22237,15 @@ oslc_sysml_shapes:PerformActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:PortConjugationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PortConjugation ; oslc:property [ a oslc:Property ; + oslc:name "originalPortDefinition" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:originalPortDefinition ; + oslc:range oslc_sysml:PortDefinition ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The PortDefinition being conjugated."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:source ; @@ -22246,23 +22255,23 @@ oslc_sysml_shapes:PortConjugationShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConjugatedPortDefinition that is conjugate to the originalPortDefinition."^^rdf:XMLLiteral ], + dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "originalPortDefinition" ; + oslc:name "conjugatedPortDefinition" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:originalPortDefinition ; - oslc:range oslc_sysml:PortDefinition ; + oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; + oslc:range oslc_sysml:ConjugatedPortDefinition ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The PortDefinition being conjugated."^^rdf:XMLLiteral ], + dcterms:description "The ConjugatedPortDefinition that is conjugate to the originalPortDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -22272,15 +22281,6 @@ oslc_sysml_shapes:PortConjugationShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:conjugatedType, oslc_sysml_shapes:contributor, @@ -22330,23 +22330,29 @@ oslc_sysml_shapes:PortConjugationShape a oslc:ResourceShape ; oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PortDefinition ; oslc:property [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -22357,32 +22363,32 @@ oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "conjugatedPortDefinition" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; + oslc:range oslc_sysml:ConjugatedPortDefinition ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The that is conjugate to this PortDefinition.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -22393,20 +22399,14 @@ oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -22417,29 +22417,23 @@ oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The that is conjugate to this PortDefinition.."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -22450,23 +22444,29 @@ oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -22560,32 +22560,29 @@ oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:PortUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:PortUsage ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -22596,71 +22593,74 @@ oslc_sysml_shapes:PortUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "portDefinition" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:portDefinition ; + oslc:range oslc_sysml:PortDefinition ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The occurrenceDefinitions of this PortUsage, which must all be PortDefinitions.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -22670,15 +22670,6 @@ oslc_sysml_shapes:PortUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "portDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:portDefinition ; - oslc:range oslc_sysml:PortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The occurrenceDefinitions of this PortUsage, which must all be PortDefinitions.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -22689,14 +22680,23 @@ oslc_sysml_shapes:PortUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -22827,23 +22827,14 @@ oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -22851,14 +22842,14 @@ oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -22869,14 +22860,14 @@ oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -22886,6 +22877,15 @@ oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -22957,41 +22957,41 @@ oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; oslc_sysml_shapes:RedefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Redefinition ; oslc:property [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:owningFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -23053,15 +23053,6 @@ oslc_sysml_shapes:ReferenceSubsettingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -23071,6 +23062,15 @@ oslc_sysml_shapes:ReferenceSubsettingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningFeature" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -23133,6 +23133,15 @@ oslc_sysml_shapes:ReferenceSubsettingShape a oslc:ResourceShape ; oslc_sysml_shapes:ReferenceUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ReferenceUsage ; oslc:property [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -23142,74 +23151,74 @@ oslc_sysml_shapes:ReferenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -23219,15 +23228,6 @@ oslc_sysml_shapes:ReferenceUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -23238,23 +23238,23 @@ oslc_sysml_shapes:ReferenceUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -23437,32 +23437,14 @@ oslc_sysml_shapes:RelationshipShape a oslc:ResourceShape ; oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:RenderingDefinition ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -23473,14 +23455,14 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -23488,23 +23470,23 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -23514,12 +23496,6 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -23530,32 +23506,47 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -23565,6 +23556,15 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -23659,23 +23659,23 @@ oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:RenderingUsage ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -23685,15 +23685,6 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -23701,23 +23692,23 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -23728,20 +23719,23 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -23752,14 +23746,29 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -23778,15 +23787,6 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -23911,23 +23911,29 @@ oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:RequirementConstraintMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:RequirementConstraintMembership ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "kind" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:kind ; + oslc:readOnly false ; + dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Exactly-one ; @@ -23937,6 +23943,15 @@ oslc_sysml_shapes:RequirementConstraintMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -23947,35 +23962,20 @@ oslc_sysml_shapes:RequirementConstraintMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -24042,12 +24042,6 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -24058,26 +24052,14 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -24088,41 +24070,32 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -24133,32 +24106,38 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "stakeholderParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -24168,6 +24147,21 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -24175,83 +24169,89 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "subjectParameter" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "stakeholderParameter" ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "text" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:text ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "framedConcern" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; + oslc:readOnly false ; + dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -24347,74 +24347,56 @@ oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:RequirementUsage ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "text" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:text ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -24424,6 +24406,15 @@ oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -24434,38 +24425,41 @@ oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "text" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -24476,95 +24470,101 @@ oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:assumedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "stakeholderParameter" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "stakeholderParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:constraintDefinition, @@ -24691,14 +24691,14 @@ oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:RequirementVerificationMembership ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "feature" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -24709,20 +24709,11 @@ oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "kind" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:propertyDefinition oslc_sysml:kind ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConstraint" ; oslc:occurs oslc:Exactly-one ; @@ -24732,12 +24723,6 @@ oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -24748,14 +24733,29 @@ oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The owned RequirementUsage that acts as the ownedConstraint for this RequirementVerificationMembership. This will either be the verifiedRequirement, or it will subset the verifiedRequirement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "verifiedRequirement" ; oslc:occurs oslc:Exactly-one ; @@ -24766,14 +24766,14 @@ oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description " The RequirementUsage that is identified as being verified. It is the referencedConstraint of the RequirementVerificationMembership considered as a RequirementConstraintMembership, which must be a RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned RequirementUsage that acts as the ownedConstraint for this RequirementVerificationMembership. This will either be the verifiedRequirement, or it will subset the verifiedRequirement."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -24832,11 +24832,14 @@ oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:ResultExpressionMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ResultExpressionMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -24846,6 +24849,15 @@ oslc_sysml_shapes:ResultExpressionMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -24865,23 +24877,11 @@ oslc_sysml_shapes:ResultExpressionMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -24940,23 +24940,14 @@ oslc_sysml_shapes:ResultExpressionMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:ReturnParameterMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ReturnParameterMembership ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Exactly-one ; @@ -24966,6 +24957,15 @@ oslc_sysml_shapes:ReturnParameterMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -24973,23 +24973,23 @@ oslc_sysml_shapes:ReturnParameterMembershipShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -25048,14 +25048,20 @@ oslc_sysml_shapes:ReturnParameterMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SatisfyRequirementUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -25074,6 +25080,15 @@ oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -25084,56 +25099,53 @@ oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "text" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:text ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "assumedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:assumedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -25144,59 +25156,44 @@ oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "stakeholderParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], + dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -25216,56 +25213,59 @@ oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "assumedConstraint" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "text" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:assertedConstraint, oslc_sysml_shapes:behavior, @@ -25396,23 +25396,23 @@ oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SelectExpression ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -25423,32 +25423,14 @@ oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -25459,29 +25441,23 @@ oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -25500,6 +25476,30 @@ oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -25592,59 +25592,74 @@ oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SendActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -25655,14 +25670,14 @@ oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -25673,41 +25688,38 @@ oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "receiverArgument" ; oslc:occurs oslc:Zero-or-one ; @@ -25718,17 +25730,14 @@ oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "An Expression whose result is bound to the receiver input parameter of this SendActionUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "payloadArgument" ; oslc:occurs oslc:Exactly-one ; @@ -25738,15 +25747,6 @@ oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "An Expression whose result is bound to the payload input parameter of this SendActionUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -25871,6 +25871,15 @@ oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:SpecializationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Specialization ; oslc:property [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -25888,15 +25897,6 @@ oslc_sysml_shapes:SpecializationShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -25946,29 +25946,32 @@ oslc_sysml_shapes:SpecializationShape a oslc:ResourceShape ; oslc_sysml_shapes:StakeholderMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:StakeholderMembership ; oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -25979,23 +25982,20 @@ oslc_sysml_shapes:StakeholderMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "visibility" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -26055,41 +26055,41 @@ oslc_sysml_shapes:StakeholderMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:StateDefinition ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "entryAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:entryAction ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage of this StateDefinition to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "doAction" ; oslc:occurs oslc:Zero-or-one ; @@ -26100,23 +26100,38 @@ oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsage of this StateDefinition to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateDefinition to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConcern" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -26127,14 +26142,20 @@ oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "entryAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:entryAction ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "action" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:action ; oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateDefinition to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -26145,53 +26166,41 @@ oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isParallel" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; - oslc:readOnly false ; - dcterms:description "Whether the ownedStates of this StateDefinition are to all be performed in parallel. If true, none of the ownedActions (which includes ownedStates) may have any incoming or outgoing Transitions. If false, only one ownedState may be performed at a time."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; @@ -26202,38 +26211,29 @@ oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:name "isParallel" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isParallel ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "Whether the ownedStates of this StateDefinition are to all be performed in parallel. If true, none of the ownedActions (which includes ownedStates) may have any incoming or outgoing Transitions. If false, only one ownedState may be performed at a time."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; + oslc:name "exitAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:exitAction ; oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage of this StateDefinition to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -26329,23 +26329,14 @@ oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:StateSubactionMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:StateSubactionMembership ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "action" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:action ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage that is the ownedMemberFeature of this StateSubactionMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -26356,23 +26347,29 @@ oslc_sysml_shapes:StateSubactionMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "action" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:visibility ; + oslc:readOnly false ; + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage that is the ownedMemberFeature of this StateSubactionMembership."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Exactly-one ; @@ -26382,18 +26379,21 @@ oslc_sysml_shapes:StateSubactionMembershipShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "kind" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:kind ; oslc:readOnly false ; dcterms:description "Whether this StateSubactionMembership is for an entry, do or exit ActionUsage.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -26451,23 +26451,29 @@ oslc_sysml_shapes:StateSubactionMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:StateUsage ; oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -26478,86 +26484,83 @@ oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "entryAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:entryAction ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "isParallel" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isParallel ; + oslc:readOnly false ; + dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "doAction" ; oslc:occurs oslc:Zero-or-one ; @@ -26568,11 +26571,23 @@ oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "exitAction" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:exitAction ; + oslc:range oslc_sysml:ActionUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -26580,23 +26595,14 @@ oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "entryAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:entryAction ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -26607,20 +26613,14 @@ oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isParallel" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; - oslc:readOnly false ; - dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -26746,14 +26746,14 @@ oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:StepShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Step ; oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -26764,23 +26764,14 @@ oslc_sysml_shapes:StepShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -26800,41 +26791,50 @@ oslc_sysml_shapes:StepShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:contributor, @@ -26941,32 +26941,32 @@ oslc_sysml_shapes:StructureShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -27036,6 +27036,15 @@ oslc_sysml_shapes:StructureShape a oslc:ResourceShape ; oslc_sysml_shapes:SubclassificationShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Subclassification ; oslc:property [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -27053,15 +27062,6 @@ oslc_sysml_shapes:SubclassificationShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -27114,14 +27114,14 @@ oslc_sysml_shapes:SubclassificationShape a oslc:ResourceShape ; oslc_sysml_shapes:SubjectMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SubjectMembership ; oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -27132,29 +27132,29 @@ oslc_sysml_shapes:SubjectMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; @@ -27223,15 +27223,6 @@ oslc_sysml_shapes:SubjectMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:SubsettingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Subsetting ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "owningFeature" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningFeature ; @@ -27240,6 +27231,15 @@ oslc_sysml_shapes:SubsettingShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -27250,14 +27250,14 @@ oslc_sysml_shapes:SubsettingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -27309,59 +27309,50 @@ oslc_sysml_shapes:SubsettingShape a oslc:ResourceShape ; oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SuccessionAsUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:guardExpression ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -27372,14 +27363,14 @@ oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -27390,50 +27381,50 @@ oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -27443,6 +27434,15 @@ oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -27453,14 +27453,14 @@ oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "guardExpression" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -27596,38 +27596,29 @@ oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SuccessionFlowConnectionUsage ; oslc:property [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -27638,86 +27629,74 @@ oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:guardExpression ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "guardExpression" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -27728,20 +27707,41 @@ oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -27761,14 +27761,14 @@ oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, @@ -27913,6 +27913,24 @@ oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc:describes oslc_sysml:SuccessionItemFlow ; oslc:property [ a oslc:Property ; + oslc:name "targetFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:targetFeature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "guardExpression" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:guardExpression ; + oslc:range oslc_sysml:Expression ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; oslc:propertyDefinition oslc_sysml:owningType ; @@ -27920,16 +27938,25 @@ oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -27940,50 +27967,50 @@ oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:propertyDefinition oslc_sysml:parameter ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -27994,32 +28021,14 @@ oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -28029,15 +28038,6 @@ oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:behavior, @@ -28143,6 +28143,15 @@ oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Succession ; oslc:property [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:guardExpression ; @@ -28152,14 +28161,14 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -28169,33 +28178,6 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -28206,14 +28188,14 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "targetFeature" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -28232,6 +28214,15 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -28242,23 +28233,32 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "targetFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:targetFeature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:association, oslc_sysml_shapes:connectorEnd, @@ -28357,29 +28357,23 @@ oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:TerminateActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -28390,23 +28384,20 @@ oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; @@ -28417,23 +28408,14 @@ oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -28444,23 +28426,32 @@ oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -28471,23 +28462,32 @@ oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; @@ -28679,14 +28679,11 @@ oslc_sysml_shapes:TextualRepresentationShape a oslc:ResourceShape ; oslc_sysml_shapes:TransitionFeatureMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:TransitionFeatureMembership ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "kind" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:kind ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "Whether this TransitionFeatureMembership is for a trigger, guard or effect."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -28694,47 +28691,50 @@ oslc_sysml_shapes:TransitionFeatureMembershipShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "feature" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "owningType" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether this TransitionFeatureMembership is for a trigger, guard or effect."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -28793,83 +28793,86 @@ oslc_sysml_shapes:TransitionFeatureMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:TransitionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:TransitionUsage ; oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:ActionUsage ; + oslc:name "variant" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The source ActionUsage of this TransitionUsage, which becomes the source of the succession for the TransitionUsage."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "source" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The source ActionUsage of this TransitionUsage, which becomes the source of the succession for the TransitionUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "guardExpression" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Expressions that define the guards of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = guard, which must all be Expressions."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "guardExpression" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:guardExpression ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Expressions that define the guards of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = guard, which must all be Expressions."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "target" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The target ActionUsage of this TransitionUsage, which is the targetFeature of the succession for the TransitionUsage.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -28880,23 +28883,29 @@ oslc_sysml_shapes:TransitionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -28907,23 +28916,29 @@ oslc_sysml_shapes:TransitionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -28934,29 +28949,14 @@ oslc_sysml_shapes:TransitionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target ActionUsage of this TransitionUsage, which is the targetFeature of the succession for the TransitionUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -29092,14 +29092,23 @@ oslc_sysml_shapes:TriggerInvocationExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; @@ -29110,53 +29119,53 @@ oslc_sysml_shapes:TriggerInvocationExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; + oslc:propertyDefinition oslc_sysml:feature ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "kind" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:kind ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Indicates which of the Functions from the Triggers model in the Kernel Semantic Library is to be invoked by this TriggerInvocationExpression."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "kind" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - dcterms:description "Indicates which of the Functions from the Triggers model in the Kernel Semantic Library is to be invoked by this TriggerInvocationExpression."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:name "type" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; @@ -29167,32 +29176,23 @@ oslc_sysml_shapes:TriggerInvocationExpressionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:argument, oslc_sysml_shapes:behavior, @@ -29284,14 +29284,14 @@ oslc_sysml_shapes:TriggerInvocationExpressionShape a oslc:ResourceShape ; oslc_sysml_shapes:TypeFeaturingShape a oslc:ResourceShape ; oslc:describes oslc_sysml:TypeFeaturing ; oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "type" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; @@ -29302,14 +29302,14 @@ oslc_sysml_shapes:TypeFeaturingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:name "source" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:source ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "featuringType" ; oslc:occurs oslc:Exactly-one ; @@ -29320,14 +29320,14 @@ oslc_sysml_shapes:TypeFeaturingShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that features the featureOfType. It is the target of the TypeFeaturing."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -29377,15 +29377,6 @@ oslc_sysml_shapes:TypeFeaturingShape a oslc:ResourceShape ; oslc_sysml_shapes:TypeShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Type ; oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:intersectingType ; @@ -29394,15 +29385,6 @@ oslc_sysml_shapes:TypeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; @@ -29421,6 +29403,24 @@ oslc_sysml_shapes:TypeShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -29489,14 +29489,14 @@ oslc_sysml_shapes:TypeShape a oslc:ResourceShape ; oslc_sysml_shapes:UnioningShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Unioning ; oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:name "target" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:target ; + oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeUnioned, as described in Type::unioningType."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -29507,14 +29507,14 @@ oslc_sysml_shapes:UnioningShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; + oslc:name "unioningType" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "Type that partly determines interpretations of typeUnioned, as described in Type::unioningType."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -29563,41 +29563,50 @@ oslc_sysml_shapes:UnioningShape a oslc:ResourceShape ; oslc_sysml_shapes:UsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:Usage ; oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -29608,23 +29617,23 @@ oslc_sysml_shapes:UsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -29635,56 +29644,47 @@ oslc_sysml_shapes:UsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -29803,14 +29803,23 @@ oslc_sysml_shapes:UsageShape a oslc:ResourceShape ; oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:UseCaseDefinition ; oslc:property [ a oslc:Property ; - oslc:name "ownedRequirement" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConcern" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "result" ; oslc:occurs oslc:Exactly-one ; @@ -29821,32 +29830,41 @@ oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "includedUseCase" ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:includedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are included by this UseCaseDefinition, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseDefinition.."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; @@ -29857,74 +29875,56 @@ oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -29932,74 +29932,74 @@ oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "includedUseCase" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:includedUseCase ; + oslc:range oslc_sysml:UseCaseUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The UseCaseUsages that are included by this UseCaseDefinition, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseDefinition.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:calculation, oslc_sysml_shapes:contributor, @@ -30096,6 +30096,15 @@ oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:UseCaseUsage ; oslc:property [ a oslc:Property ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "."^^rdf:XMLLiteral ], + [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; oslc:propertyDefinition oslc_sysml:variantMembership ; @@ -30105,59 +30114,65 @@ oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "objectiveRequirement" ; oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -30168,86 +30183,65 @@ oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "includedUseCase" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:includedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "actorParameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -30258,32 +30252,38 @@ oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "includedUseCase" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:includedUseCase ; + oslc:range oslc_sysml:UseCaseUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -30411,14 +30411,14 @@ oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:VariantMembershipShape a oslc:ResourceShape ; oslc:describes oslc_sysml:VariantMembership ; oslc:property [ a oslc:Property ; - oslc:name "source" ; + oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; + oslc:propertyDefinition oslc_sysml:target ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; @@ -30426,14 +30426,14 @@ oslc_sysml_shapes:VariantMembershipShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "target" ; + oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; + oslc:propertyDefinition oslc_sysml:source ; oslc:range oslc_sysml:Element ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], + dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -30491,77 +30491,74 @@ oslc_sysml_shapes:VariantMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:VerificationCaseDefinition ; oslc:property [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "differencingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -30572,62 +30569,41 @@ oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -30635,23 +30611,32 @@ oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "action" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:action ; + oslc:range oslc_sysml:ActionUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "verifiedRequirement" ; oslc:occurs oslc:Zero-or-many ; @@ -30662,32 +30647,47 @@ oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The RequirementUsages verified by this VerificationCaseDefinition, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "action" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:calculation, oslc_sysml_shapes:contributor, @@ -30784,14 +30784,44 @@ oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:VerificationCaseUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:VerificationCaseUsage ; oslc:property [ a oslc:Property ; - oslc:name "type" ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; + oslc:readOnly false ; + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -30802,47 +30832,41 @@ oslc_sysml_shapes:VerificationCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "chainingFeature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "verifiedRequirement" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:verifiedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages verified by this VerificationCaseUsage, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -30853,125 +30877,101 @@ oslc_sysml_shapes:VerificationCaseUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "result" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; + oslc:propertyDefinition oslc_sysml:result ; oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "verifiedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:verifiedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages verified by this VerificationCaseUsage, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "featuringType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:name "objectiveRequirement" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:objectiveRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; + oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, @@ -31099,23 +31099,32 @@ oslc_sysml_shapes:VerificationCaseUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ViewDefinition ; oslc:property [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "ownedRendering" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "satisfiedViewpoint" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The composite ownedRequirements of this ViewDefinition that are ViewpointUsages for viewpoints satisfied by the ViewDefinition."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedConcern" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedConcern ; + oslc:range oslc_sysml:ConcernUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -31135,23 +31144,50 @@ oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "ownedRequirement" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "satisfiedViewpoint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; + oslc:range oslc_sysml:ViewpointUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The composite ownedRequirements of this ViewDefinition that are ViewpointUsages for viewpoints satisfied by the ViewDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "viewCondition" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:viewCondition ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Expressions related to this ViewDefinition by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -31162,23 +31198,14 @@ oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewRendering" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsage to be used to render views defined by this ViewDefinition, which is the referencedRendering of the ViewRenderingMembership of the ViewDefinition."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -31186,47 +31213,14 @@ oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:propertyDefinition oslc_sysml:differencingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewCondition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewCondition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions related to this ViewDefinition by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; @@ -31246,14 +31240,20 @@ oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "viewRendering" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:viewRendering ; + oslc:range oslc_sysml:RenderingUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The RenderingUsage to be used to render views defined by this ViewDefinition, which is the referencedRendering of the ViewRenderingMembership of the ViewDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -31357,23 +31357,14 @@ oslc_sysml_shapes:ViewRenderingMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned RenderingUsage that is either itself the referencedRendering or subsets the referencedRendering."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "feature" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "target" ; oslc:occurs oslc:Zero-or-many ; @@ -31384,14 +31375,11 @@ oslc_sysml_shapes:ViewRenderingMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "visibility" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:visibility ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], + dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "source" ; oslc:occurs oslc:Zero-or-many ; @@ -31402,11 +31390,23 @@ oslc_sysml_shapes:ViewRenderingMembershipShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "visibility" ; + oslc:name "type" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The owned RenderingUsage that is either itself the referencedRendering or subsets the referencedRendering."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -31465,80 +31465,83 @@ oslc_sysml_shapes:ViewRenderingMembershipShape a oslc:ResourceShape ; oslc_sysml_shapes:ViewUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ViewUsage ; oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "viewCondition" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:viewCondition ; + oslc:range oslc_sysml:Expression ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Expressions related to this ViewUsage by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; + oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:propertyDefinition oslc_sysml:type ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; + oslc:propertyDefinition oslc_sysml:usage ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; + oslc:name "satisfiedViewpoint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; + oslc:range oslc_sysml:ViewpointUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + dcterms:description "The nestedRequirements of this ViewUsage that are ViewpointUsages for (additional) viewpoints satisfied by the ViewUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "viewRendering" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:name "feature" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsage to be used to render views defined by this ViewUsage, which is the referencedRendering of the ViewRenderingMembership of the ViewUsage."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; @@ -31548,6 +31551,24 @@ oslc_sysml_shapes:ViewUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "directedUsage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "viewRendering" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:viewRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsage to be used to render views defined by this ViewUsage, which is the referencedRendering of the ViewRenderingMembership of the ViewUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -31566,15 +31587,6 @@ oslc_sysml_shapes:ViewUsageShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewCondition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewCondition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions related to this ViewUsage by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -31585,41 +31597,29 @@ oslc_sysml_shapes:ViewUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "satisfiedViewpoint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The nestedRequirements of this ViewUsage that are ViewpointUsages for (additional) viewpoints satisfied by the ViewUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -31754,14 +31754,20 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The PartUsages that identify the stakeholders with concerns framed by this ViewpointDefinition, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "text" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:text ; + oslc:readOnly false ; + dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "parameter" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:parameter ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isModelLevelEvaluable" ; oslc:occurs oslc:Exactly-one ; @@ -31769,56 +31775,47 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "ownedConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:ownedConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; + oslc:name "ownedRequirement" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRequirement ; + oslc:range oslc_sysml:RequirementUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], + dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; @@ -31829,59 +31826,50 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRendering" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; + oslc:propertyDefinition oslc_sysml:variant ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "ownedConcern" ; oslc:occurs oslc:Zero-or-many ; @@ -31892,38 +31880,41 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "text" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedConstraint" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], + dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "isVariation" ; oslc:occurs oslc:Exactly-one ; @@ -31931,14 +31922,14 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:readOnly false ; dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "framedConcern" ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -31949,20 +31940,20 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; + oslc:name "requiredConstraint" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "stakeholderParameter" ; oslc:occurs oslc:Zero-or-many ; @@ -31972,6 +31963,15 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "ownedRendering" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:ownedRendering ; + oslc:range oslc_sysml:RenderingUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:contributor, oslc_sysml_shapes:created, @@ -32067,59 +32067,62 @@ oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:ViewpointUsage ; oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; oslc:name "isIndividual" ; oslc:occurs oslc:Exactly-one ; oslc:propertyDefinition oslc_sysml:isIndividual ; oslc:readOnly false ; dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "actorParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:actorParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; + oslc:name "intersectingType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:intersectingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:name "reqId" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:reqId ; + oslc:readOnly false ; + dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "owningType" ; + oslc:occurs oslc:Zero-or-one ; + oslc:propertyDefinition oslc_sysml:owningType ; + oslc:range oslc_sysml:Type ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "unioningType" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; @@ -32130,14 +32133,14 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "viewpointStakeholder" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:viewpointStakeholder ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "The PartUsages that identify the stakeholders with concerns framed by this ViewpointUsage, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; @@ -32148,50 +32151,56 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "framedConcern" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; + oslc:propertyDefinition oslc_sysml:featuringType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "requiredConstraint" ; + oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; + oslc:propertyDefinition oslc_sysml:chainingFeature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], + dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "type" ; + oslc:name "text" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:text ; + oslc:readOnly false ; + dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "stakeholderParameter" ; + oslc:name "framedConcern" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:framedConcern ; + oslc:range oslc_sysml:ConcernUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], + dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "parameter" ; oslc:occurs oslc:Zero-or-many ; @@ -32202,14 +32211,23 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "chainingFeature" ; + oslc:name "usage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "requiredConstraint" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:requiredConstraint ; + oslc:range oslc_sysml:ConstraintUsage ; + oslc:readOnly false ; + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "assumedConstraint" ; oslc:occurs oslc:Zero-or-many ; @@ -32220,44 +32238,44 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; + oslc:name "isModelLevelEvaluable" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], + dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "stakeholderParameter" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:stakeholderParameter ; + oslc:range oslc_sysml:PartUsage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "result" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:result ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; + oslc:readOnly false ; + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "subjectParameter" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:subjectParameter ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; @@ -32268,32 +32286,14 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewpointStakeholder" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewpointStakeholder ; - oslc:range oslc_sysml:PartUsage ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The PartUsages that identify the stakeholders with concerns framed by this ViewpointUsage, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointUsage."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, oslc_sysml_shapes:constraintDefinition, @@ -32421,29 +32421,20 @@ oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; oslc_sysml_shapes:WhileLoopActionUsageShape a oslc:ResourceShape ; oslc:describes oslc_sysml:WhileLoopActionUsage ; oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; + oslc:name "unioningType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; + oslc:propertyDefinition oslc_sysml:unioningType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; + oslc:name "isVariation" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isVariation ; oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], + dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "owningType" ; oslc:occurs oslc:Zero-or-one ; @@ -32454,47 +32445,50 @@ oslc_sysml_shapes:WhileLoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "intersectingType" ; + oslc:name "importedMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; + oslc:propertyDefinition oslc_sysml:importedMembership ; + oslc:range oslc_sysml:Membership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:name "usage" ; + oslc:occurs oslc:Zero-or-many ; + oslc:propertyDefinition oslc_sysml:usage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + oslc:representation oslc:Either ; + oslc:valueType oslc:Resource ; + dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "directedUsage" ; + oslc:name "variant" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:propertyDefinition oslc_sysml:variant ; oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], + dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "importedMembership" ; + oslc:name "differencingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; + oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "unioningType" ; + oslc:name "featuringType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; + oslc:propertyDefinition oslc_sysml:featuringType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], + dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; oslc:name "chainingFeature" ; oslc:occurs oslc:Zero-or-many ; @@ -32514,50 +32508,56 @@ oslc_sysml_shapes:WhileLoopActionUsageShape a oslc:ResourceShape ; oslc:valueType oslc:Resource ; dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variant" ; + oslc:name "isIndividual" ; + oslc:occurs oslc:Exactly-one ; + oslc:propertyDefinition oslc_sysml:isIndividual ; + oslc:readOnly false ; + dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], + [ a oslc:Property ; + oslc:name "variantMembership" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:variantMembership ; + oslc:range oslc_sysml:VariantMembership ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "differencingType" ; + oslc:name "intersectingType" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; + oslc:propertyDefinition oslc_sysml:intersectingType ; oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], + dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "feature" ; + oslc:name "directedUsage" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; + oslc:propertyDefinition oslc_sysml:directedUsage ; + oslc:range oslc_sysml:Usage ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], + dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "usage" ; + oslc:name "type" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; + oslc:propertyDefinition oslc_sysml:type ; + oslc:range oslc_sysml:Type ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], + dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], [ a oslc:Property ; - oslc:name "variantMembership" ; + oslc:name "feature" ; oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; + oslc:propertyDefinition oslc_sysml:feature ; + oslc:range oslc_sysml:Feature ; oslc:readOnly false ; oslc:representation oslc:Either ; oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], + dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], oslc_sysml_shapes:actionDefinition, oslc_sysml_shapes:aliasIds, oslc_sysml_shapes:behavior, diff --git a/specs/sysml/SysML-Vocabulary-vocab.ttl b/specs/sysml/SysML-Vocabulary-vocab.ttl index d82e8dc..c944d24 100644 --- a/specs/sysml/SysML-Vocabulary-vocab.ttl +++ b/specs/sysml/SysML-Vocabulary-vocab.ttl @@ -1,14 +1,12 @@ @prefix dcterms: . @prefix oslc_am: . -@prefix oslc_sysml: . +@prefix oslc_sysml: . @prefix owl: . @prefix rdf: . @prefix rdfs: . @prefix vann: . @prefix xsd: . - owl:sameAs - oslc_sysml:AcceptActionUsage a rdfs:Class ; rdfs:label "AcceptActionUsage" ; rdfs:comment "An AcceptActionUsage is an ActionUsage that specifies the acceptance of an incomingTransfer from the Occurrence given by the result of its receiverArgument Expression. (If no receiverArgument is provided, the default is the this context of the AcceptActionUsage.) The payload of the accepted Transfer is output on its payloadParameter. Which Transfers may be accepted is determined by conformance to the typing and (potentially) binding of the payloadParameter." ; diff --git a/specs/sysml/sysml-shapes.html b/specs/sysml/sysml-shapes.html index b9e6e55..2a36ad8 100644 --- a/specs/sysml/sysml-shapes.html +++ b/specs/sysml/sysml-shapes.html @@ -70,11 +70,11 @@ }, { title: "OSLC Systems Modeling Language Version 2.0. Part 4: Machine Readable Vocabulary Terms", - href: "sysml-vocab.ttl", + href: "SysML-Vocabulary-vocab.ttl", }, { title: "OSLC Systems Modeling Language Version 2.0. Part 5: Machine Readable Constraints", - href: "sysml-shapes.ttl", + href: "SysML-Shapes-shapes.ttl", }, ], @@ -292,7 +292,7 @@

Resource Constraints

Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
Resource Constraints
. -@prefix jazz_am: . -@prefix oslc: . -@prefix oslc_sysml: . -@prefix oslc_sysml_shapes: . -@prefix rdf: . -@prefix rdfs: . -@prefix xsd: . - -oslc_sysml_shapes: a oslc:ResourceShapeConstraints ; - rdfs:label "OSLC System Modeling Language (SysML) Constraints" ; - dcterms:dateCopyrighted "2012-2024" ; - dcterms:description "

Constraints on vocabulary terms defined in the OSLC System Modeling Language (SysML) namespace.

"^^rdf:XMLLiteral ; - dcterms:hasVersion "PSD01" ; - dcterms:isPartOf ; - dcterms:issued "2025-02-01"^^xsd:date ; - dcterms:license ; - dcterms:source ; - dcterms:title "OSLC System Modeling Language (SysML) Version 2.0 Constraints" . - -oslc_sysml_shapes:AcceptActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AcceptActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "payloadArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:payloadArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the payload parameter of this AcceptActionUsage. If provided, the AcceptActionUsage will only accept a Transfer with exactly this payload."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "receiverArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:receiverArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the receiver input parameter of this AcceptActionUsage."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:payloadParameter, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AcceptActionUsage is an ActionUsage that specifies the acceptance of an incomingTransfer from the Occurrence given by the result of its receiverArgument Expression. (If no receiverArgument is provided, the default is the this context of the AcceptActionUsage.) The payload of the accepted Transfer is output on its payloadParameter. Which Transfers may be accepted is determined by conformance to the typing and (potentially) binding of the payloadParameter."^^rdf:XMLLiteral ; - dcterms:title "AcceptActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ActionDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ActionDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ActionDefinition is a Definition that is also a Behavior that defines an Action performed by a system or part of a system."^^rdf:XMLLiteral ; - dcterms:title "ActionDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ActionUsage is a Usage that is also a Step, and, so, is typed by a Behavior. Nominally, if the type is an ActionDefinition, an ActionUsage is a Usage of that ActionDefinition within a system. However, other kinds of kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "ActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ActorMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ActorMembership ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedActorParameter, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberParameter, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ActorMembership is a ParameterMembership that identifies a PartUsage as an actor parameter, which specifies a role played by an external entity in interaction with the owningType of the ActorMembership."^^rdf:XMLLiteral ; - dcterms:title "ActorMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AllocationDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AllocationDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:allocation, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:connectionEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AllocationDefinition is a ConnectionDefinition that specifies that some or all of the responsibility to realize the intent of the source is allocated to the target instances. Such allocations define mappings across the various structures and hierarchies of a system model, perhaps as a precursor to more rigorous specifications and implementations. An AllocationDefinition can itself be refined using nested allocations that give a finer-grained decomposition of the containing allocation mapping."^^rdf:XMLLiteral ; - dcterms:title "AllocationDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AllocationUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AllocationUsage ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:allocationDefinition, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectionDefinition, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AllocationUsage is a usage of an AllocationDefinition asserting the allocation of the source feature to the target feature."^^rdf:XMLLiteral ; - dcterms:title "AllocationUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AnalysisCaseDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AnalysisCaseDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "resultExpression" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:resultExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression used to compute the result of the AnalysisCaseDefinition, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AnalysisCaseDefinition is a CaseDefinition for the case of carrying out an analysis."^^rdf:XMLLiteral ; - dcterms:title "AnalysisCaseDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AnalysisCaseUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AnalysisCaseUsage ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "resultExpression" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:resultExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression used to compute the result of the AnalysisCaseUsage, owned via a ResultExpressionMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:analysisCaseDefinition, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:caseDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AnalysisCaseUsage is a Usage of an AnalysisCaseDefinition."^^rdf:XMLLiteral ; - dcterms:title "AnalysisCaseUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AnnotatingElementShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AnnotatingElement ; - oslc:property [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AnnotatingElement is an Element that provides additional description of or metadata on some other Element. An AnnotatingElement is either attached to its annotatedElements by Annotation Relationships, or it implicitly annotates its owningNamespace."^^rdf:XMLLiteral ; - dcterms:title "AnnotatingElementShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AnnotationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Annotation ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element that is annotated by the annotatingElement of this Annotation."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotatingElement, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningAnnotatedElement, - oslc_sysml_shapes:owningAnnotatingElement, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Annotation is a Relationship between an AnnotatingElement and the Element that is annotated by that AnnotatingElement."^^rdf:XMLLiteral ; - dcterms:title "AnnotationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AssertConstraintUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AssertConstraintUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:assertedConstraint, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNegated, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AssertConstraintUsage is a ConstraintUsage that is also an Invariant and, so, is asserted to be true (by default). Unless it is the AssertConstraintUsage itself, the asserted ConstraintUsage is related to the AssertConstraintUsage by a ReferenceSubsetting Relationship."^^rdf:XMLLiteral ; - dcterms:title "AssertConstraintUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AssignmentActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AssignmentActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "referent" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referent ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature whose value is to be set."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:targetArgument, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:valueExpression ; - dcterms:description "An AssignmentActionUsage is an ActionUsage that is defined, directly or indirectly, by the ActionDefinition AssignmentAction from the Systems Model Library. It specifies that the value of the referent Feature, relative to the target given by the result of the targetArgument Expression, should be set to the result of the valueExpression."^^rdf:XMLLiteral ; - dcterms:title "AssignmentActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AssociationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Association ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Association is a Relationship and a Classifier to enable classification of links between things (in the universe). The co-domains (types) of the associationEnd Features are the relatedTypes, as co-domain and participants (linked things) of an Association identify each other."^^rdf:XMLLiteral ; - dcterms:title "AssociationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AssociationStructureShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AssociationStructure ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AssociationStructure is an Association that is also a Structure, classifying link objects that are both links and objects. As objects, link objects can be created and destroyed, and their non-end Features can change over time. However, the values of the end Features of a link object are fixed and cannot change over its lifetime."^^rdf:XMLLiteral ; - dcterms:title "AssociationStructureShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AttributeDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AttributeDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AttributeDefinition is a Definition and a DataType of information about a quality or characteristic of a system or part of a system that has no independent identity other than its value. All features of an AttributeDefinition must be referential (non-composite)."^^rdf:XMLLiteral ; - dcterms:title "AttributeDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:AttributeUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:AttributeUsage ; - oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:attributeDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An AttributeUsage is a Usage whose type is a DataType. Nominally, if the type is an AttributeDefinition, an AttributeUsage is a usage of a AttributeDefinition to represent the value of some system quality or characteristic. However, other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries. An AttributeUsage itself as well as all its nested features must be referential (non-composite)."^^rdf:XMLLiteral ; - dcterms:title "AttributeUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:BehaviorShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Behavior ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Behavior coordinates occurrences of other Behaviors, as well as changes in objects. Behaviors can be decomposed into Steps and be characterized by parameters."^^rdf:XMLLiteral ; - dcterms:title "BehaviorShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:BindingConnectorAsUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:BindingConnectorAsUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A BindingConnectorAsUsage is both a BindingConnector and a ConnectorAsUsage."^^rdf:XMLLiteral ; - dcterms:title "BindingConnectorAsUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:BindingConnectorShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:BindingConnector ; - oslc:property [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A BindingConnector is a binary Connector that requires its relatedFeatures to identify the same things (have the same values)."^^rdf:XMLLiteral ; - dcterms:title "BindingConnectorShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:BooleanExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:BooleanExpression ; - oslc:property [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A BooleanExpression is a Boolean-valued Expression whose type is a Predicate. It represents a logical condition resulting from the evaluation of the Predicate."^^rdf:XMLLiteral ; - dcterms:title "BooleanExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CalculationDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:CalculationDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A CalculationDefinition is an ActionDefinition that also defines a Function producing a result.."^^rdf:XMLLiteral ; - dcterms:title "CalculationDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CalculationUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:CalculationUsage ; - oslc:property [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A CalculationUsage is an ActionUsage that is also an Expression, and, so, is typed by a Function. Nominally, if the type is a CalculationDefinition, a CalculationUsage is a Usage of that CalculationDefinition within a system. However, other kinds of kernel Functions are also allowed, to permit use of Functions from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "CalculationUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CaseDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:CaseDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A CaseDefinition is a CalculationDefinition for a process, often involving collecting evidence or data, relative to a subject, possibly involving the collaboration of one or more other actors, producing a result that meets an objective."^^rdf:XMLLiteral ; - dcterms:title "CaseDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CaseUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:CaseUsage ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:caseDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A CaseUsage is a Usage of a CaseDefinition."^^rdf:XMLLiteral ; - dcterms:title "CaseUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ClassShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Class ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Class is a Classifier of things (in the universe) that can be distinguished without regard to how they are related to other things (via Features). This means multiple things classified by the same Class can be distinguished, even when they are related other things in exactly the same way."^^rdf:XMLLiteral ; - dcterms:title "ClassShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ClassifierShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Classifier ; - oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Classifier is a Type that classifies:."^^rdf:XMLLiteral ; - dcterms:title "ClassifierShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CollectExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:CollectExpression ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:operator, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A CollectExpression is an OperatorExpression whose operator is \"collect\", which resolves to the Function ControlFunctions::collect from the Kernel Functions Library."^^rdf:XMLLiteral ; - dcterms:title "CollectExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:CommentShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Comment ; - oslc:property [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:body ; - oslc:readOnly false ; - dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:locale, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Comment is an AnnotatingElement whose body in some way describes its annotatedElements."^^rdf:XMLLiteral ; - dcterms:title "CommentShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConcernDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConcernDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConcernDefinition is a RequirementDefinition that one or more stakeholders may be interested in having addressed. These stakeholders are identified by the ownedStakeholdersof the ConcernDefinition."^^rdf:XMLLiteral ; - dcterms:title "ConcernDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConcernUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConcernUsage ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:concernDefinition, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:requirementDefinition, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConcernUsage is a Usage of a ConcernDefinition."^^rdf:XMLLiteral ; - dcterms:title "ConcernUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConjugatedPortDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConjugatedPortDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The that is conjugate to this PortDefinition.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "originalPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:originalPortDefinition ; - oslc:range oslc_sysml:PortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The original PortDefinition for this ConjugatedPortDefinition, which is the owningNamespace of the ConjugatedPortDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedPortConjugator, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConjugatedPortDefinition is a PortDefinition that is a PortDefinition of its original PortDefinition. That is, a ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition. Every PortDefinition (that is not itself a ConjugatedPortDefinition) has exactly one corresponding ConjugatedPortDefinition, whose effective name is the name of the originalPortDefinition, with the character ~ prepended."^^rdf:XMLLiteral ; - dcterms:title "ConjugatedPortDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConjugatedPortTypingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConjugatedPortTyping ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The type of this ConjugatedPortTyping considered as a FeatureTyping, which must be a ConjugatedPortDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "portDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:portDefinition ; - oslc:range oslc_sysml:PortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The originalPortDefinition of the conjugatedPortDefinition of this ConjugatedPortTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typedFeature ; - dcterms:description "A ConjugatedPortTyping is a FeatureTyping whose type is a ConjugatedPortDefinition. (This relationship is intended to be an abstract-syntax marker for a special surface notation for conjugated typing of ports.)."^^rdf:XMLLiteral ; - dcterms:title "ConjugatedPortTypingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConjugationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Conjugation ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:conjugatedType, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:originalType, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Conjugation is a Relationship between two types in which the conjugatedType inherits all the Features of the originalType, but with all input and output Features reversed. That is, any Features with a direction in relative to the originalType are considered to have an effective direction of out relative to the conjugatedType and, similarly, Features with direction out in the originalType are considered to have an effective direction of in in the conjugatedType. Features with direction inout, or with no direction, in the originalType, are inherited without change."^^rdf:XMLLiteral ; - dcterms:title "ConjugationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConnectionDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConnectionDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:connectionEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConnectionDefinition is a PartDefinition that is also an AssociationStructure. The end Features of a ConnectionDefinition must be Usages."^^rdf:XMLLiteral ; - dcterms:title "ConnectionDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConnectionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConnectionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectionDefinition, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConnectionUsage is a ConnectorAsUsage that is also a PartUsage. Nominally, if its type is a ConnectionDefinition, then a ConnectionUsage is a Usage of that ConnectionDefinition, representing a connection between parts of a system. However, other kinds of kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "ConnectionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConnectorAsUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConnectorAsUsage ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConnectorAsUsage is both a Connector and a Usage. ConnectorAsUsage cannot itself be instantiated in a SysML model, but it is the base class for the concrete classes BindingConnectorAsUsage, SuccessionAsUsage and ConnectionUsage."^^rdf:XMLLiteral ; - dcterms:title "ConnectorAsUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConnectorShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Connector ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Connector is a usage of Associations, with links restricted according to instances of the Type in which they are used (domain of the Connector). The associations of the Connector restrict what kinds of things might be linked. The Connector further restricts these links to be between values of Features on instances of its domain."^^rdf:XMLLiteral ; - dcterms:title "ConnectorShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConstraintDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConstraintDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConstraintDefinition is an OccurrenceDefinition that is also a Predicate that defines a constraint that may be asserted to hold on a system or part of a system."^^rdf:XMLLiteral ; - dcterms:title "ConstraintDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ConstraintUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ConstraintUsage ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ConstraintUsage is an OccurrenceUsage that is also a BooleanExpression, and, so, is typed by a Predicate. Nominally, if the type is a ConstraintDefinition, a ConstraintUsage is a Usage of that ConstraintDefinition. However, other kinds of kernel Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "ConstraintUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ControlNodeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ControlNode ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ControlNode is an ActionUsage that does not have any inherent behavior but provides constraints on incoming and outgoing Successions that are used to control other Actions. A ControlNode must be a composite owned usage of an ActionDefinition or ActionUsage."^^rdf:XMLLiteral ; - dcterms:title "ControlNodeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DataTypeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:DataType ; - oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A DataType is a Classifier of things (in the universe) that can only be distinguished by how they are related to other things (via Features). This means multiple things classified by the same DataType."^^rdf:XMLLiteral ; - dcterms:title "DataTypeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DecisionNodeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:DecisionNode ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A DecisionNode is a ControlNode that makes a selection from its outgoing Successions."^^rdf:XMLLiteral ; - dcterms:title "DecisionNodeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Definition ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Definition is a Classifier of Usages. The actual kinds of Definition that may appear in a model are given by the subclasses of Definition (possibly as extended with user-defined SemanticMetadata)."^^rdf:XMLLiteral ; - dcterms:title "DefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DependencyShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Dependency ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:client, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:supplier, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Dependency is a Relationship that indicates that one or more client Elements require one more supplier Elements for their complete specification. In general, this means that a change to one of the supplier Elements may necessitate a change to, or re-specification of, the client Elements."^^rdf:XMLLiteral ; - dcterms:title "DependencyShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DifferencingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Differencing ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typeDifferenced ; - dcterms:description "Differencing is a Relationship that makes its differencingType one of the differencingTypes of its typeDifferenced."^^rdf:XMLLiteral ; - dcterms:title "DifferencingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DisjoiningShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Disjoining ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A typeDisjoined that is also an owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:disjoiningType, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typeDisjoined ; - dcterms:description "A Disjoining is a Relationship between Types asserted to have interpretations that are not shared (disjoint) between them, identified as typeDisjoined and disjoiningType. For example, a Classifier for mammals is disjoint from a Classifier for minerals, and a Feature for people's parents is disjoint from a Feature for their children."^^rdf:XMLLiteral ; - dcterms:title "DisjoiningShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:DocumentationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Documentation ; - oslc:property [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:body ; - oslc:readOnly false ; - dcterms:description "The annotation text for the Comment."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:documentedElement, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:locale, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Documentation is a Comment that specifically documents a documentedElement, which must be its owner."^^rdf:XMLLiteral ; - dcterms:title "DocumentationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ElementFilterMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ElementFilterMembership ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:condition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "ElementFilterMembership is a Membership between a Namespace and a model-level evaluable Boolean-valued Expression, asserting that imported members of the Namespace should be filtered using the condition Expression. A general Namespace does not define any specific filtering behavior, but such behavior may be defined for various specialized kinds of Namespaces."^^rdf:XMLLiteral ; - dcterms:title "ElementFilterMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ElementShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Element ; - oslc:property oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Element is a constituent of a model that is uniquely identified relative to all other Elements. It can have Relationships with other Elements. Some of these Relationships might imply ownership of other Elements, which means that if an Element is deleted from a model, then so are all the Elements that it owns."^^rdf:XMLLiteral ; - dcterms:title "ElementShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:EndFeatureMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:EndFeatureMembership ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "EndFeatureMembership is a FeatureMembership that requires its memberFeature be owned and have isEnd = true."^^rdf:XMLLiteral ; - dcterms:title "EndFeatureMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:EnumerationDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:EnumerationDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:enumeratedValue, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An EnumerationDefinition is an AttributeDefinition all of whose instances are given by an explicit list of enumeratedValues. This is realized by requiring that the EnumerationDefinition have isVariation = true, with the enumeratedValues being its variants."^^rdf:XMLLiteral ; - dcterms:title "EnumerationDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:EnumerationUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:EnumerationUsage ; - oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:attributeDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:enumerationDefinition, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An EnumerationUsage is an AttributeUsage whose attributeDefinition is an EnumerationDefinition."^^rdf:XMLLiteral ; - dcterms:title "EnumerationUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:EventOccurrenceUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:EventOccurrenceUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:eventOccurrence, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An EventOccurrenceUsage is an OccurrenceUsage that represents another OccurrenceUsage occurring as a suboccurrence of the containing occurrence of the EventOccurrenceUsage. Unless it is the EventOccurrenceUsage itself, the referenced OccurrenceUsage is related to the EventOccurrenceUsage by a ReferenceSubsetting Relationship."^^rdf:XMLLiteral ; - dcterms:title "EventOccurrenceUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ExhibitStateUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ExhibitStateUsage ; - oslc:property [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "entryAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:entryAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isParallel" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; - oslc:readOnly false ; - dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "doAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:doAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:eventOccurrence, - oslc_sysml_shapes:exhibitedState, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:performedAction, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:stateDefinition, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ExhibitStateUsage is a StateUsage that represents the exhibiting of a StateUsage. Unless it is the StateUsage itself, the StateUsage to be exhibited is related to the ExhibitStateUsage by a ReferenceSubsetting Relationship. An ExhibitStateUsage is also a PerformActionUsage, with its exhibitedState as the performedAction."^^rdf:XMLLiteral ; - dcterms:title "ExhibitStateUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ExposeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Expose ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Expose is an Import of Memberships into a ViewUsage that provide the Elements to be included in a view. Visibility is always ignored for an Expose (i.e., isImportAll = true)."^^rdf:XMLLiteral ; - dcterms:title "ExposeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Expression ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Expression is a Step that is typed by a Function. An Expression that also has a Function as its featuringType is a computational step within that Function. An Expression always has a single result parameter, which redefines the result parameter of its defining function. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expression in the tree."^^rdf:XMLLiteral ; - dcterms:title "ExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureChainExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureChainExpression ; - oslc:property [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.

."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:operator, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FeatureChainExpression is an OperatorExpression whose operator is \".\", which resolves to the Function ControlFunctions::'.' from the Kernel Functions Library. It evaluates to the result of chaining the result Feature of its single argument Expression with its targetFeature."^^rdf:XMLLiteral ; - dcterms:title "FeatureChainExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureChainingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureChaining ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature whose values partly determine values of featureChained, as described in Feature::chainingFeature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureChained, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "FeatureChaining is a Relationship that makes its target Feature one of the chainingFeatures of its owning Feature."^^rdf:XMLLiteral ; - dcterms:title "FeatureChainingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureInvertingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureInverting ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A featureInverted that is also the owningRelatedElement of this FeatureInverting."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureInverted, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:invertingFeature, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FeatureInverting is a Relationship between Features asserting that their interpretations (sequences) are the reverse of each other, identified as featureInverted and invertingFeature. For example, a Feature identifying each person's parents is the inverse of a Feature identifying each person's children. A person identified as a parent of another will identify that other as one of their children."^^rdf:XMLLiteral ; - dcterms:title "FeatureInvertingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureMembership ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FeatureMembership is an OwningMembership between a Feature in an owningType that is also a Featuring Relationship between the Feature and the Type, in which the featuringType is the source and the featureOfType is the target. A FeatureMembership is always owned by its owningType, which is the featuringType for the FeatureMembership considered as a Featuring."^^rdf:XMLLiteral ; - dcterms:title "FeatureMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureReferenceExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureReferenceExpression ; - oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "referent" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referent ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FeatureReferenceExpression is an Expression whose result is bound to a referent Feature."^^rdf:XMLLiteral ; - dcterms:title "FeatureReferenceExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Feature ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description """A Feature is a Type that classifies relations between multiple things (in the universe). The domain of the relation is the intersection of the featuringTypes of the Feature. (The domain of a Feature with no featuringTyps is implicitly the most general Type Base::Anything from the Kernel Semantic Library.) The co-domain of the relation is the intersection of the types of the Feature. - -."""^^rdf:XMLLiteral ; - dcterms:title "FeatureShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureTypingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureTyping ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is being applied by this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A typedFeature that is also the owningRelatedElement of this FeatureTyping."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typedFeature ; - dcterms:description "FeatureTyping is Specialization in which the specific Type is a Feature. This means the set of instances of the (specific) typedFeature is a subset of the set of instances of the (general) type. In the simplest case, the type is a Classifier, whereupon the typedFeature has values that are instances of the Classifier."^^rdf:XMLLiteral ; - dcterms:title "FeatureTypingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeatureValueShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FeatureValue ; - oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression that provides the value of the featureWithValue as its result."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureWithValue, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isDefault, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isInitial, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FeatureValue is a Membership that identifies a particular member Expression that provides the value of the Feature that owns the FeatureValue. The value is specified as either a bound value or an initial value, and as either a concrete or default value. A Feature can have at most one FeatureValue."^^rdf:XMLLiteral ; - dcterms:title "FeatureValueShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FeaturingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Featuring ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Featuring is a Relationship between a Type and a Feature that is featured by that Type. It asserts that every instance in the domain of the feature must be classified by the type."^^rdf:XMLLiteral ; - dcterms:title "FeaturingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FlowConnectionDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FlowConnectionDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:connectionEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:step, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FlowConnectionDefinition is a ConnectionDefinition and ActionDefinition that is also an Interaction representing flows between Usages."^^rdf:XMLLiteral ; - dcterms:title "FlowConnectionDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FlowConnectionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FlowConnectionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:connectionDefinition, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:flowConnectionDefinition, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interaction, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:itemFeature, - oslc_sysml_shapes:itemFlowEnd, - oslc_sysml_shapes:itemType, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:sourceOutputFeature, - oslc_sysml_shapes:targetInputFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FlowConnectionUsage is a ConnectionUsage that is also an ItemFlow."^^rdf:XMLLiteral ; - dcterms:title "FlowConnectionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ForLoopActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ForLoopActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:bodyAction, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:loopVariable, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:seqArgument, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ForLoopActionUsage is a LoopActionUsage that specifies that its bodyAction ActionUsage should be performed once for each value, in order, from the sequence of values obtained as the result of the seqArgument Expression, with the loopVariable set to the value for each iteration."^^rdf:XMLLiteral ; - dcterms:title "ForLoopActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ForkNodeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ForkNode ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ForkNode is a ControlNode that must be followed by successor Actions as given by all its outgoing Successions."^^rdf:XMLLiteral ; - dcterms:title "ForkNodeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FramedConcernMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:FramedConcernMembership ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsage that is the ownedConstraint of this FramedConcernMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedConcern, - oslc_sysml_shapes:referencedConstraint, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A FramedConcernMembership is a RequirementConstraintMembership for a framed ConcernUsage of a RequirementDefinition or RequirementUsage."^^rdf:XMLLiteral ; - dcterms:title "FramedConcernMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:FunctionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Function ; - oslc:property [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Function is a Behavior that has an out parameter that is identified as its result. A Function represents the performance of a calculation that produces the values of its result parameter. This calculation may be decomposed into Expressions that are steps of the Function."^^rdf:XMLLiteral ; - dcterms:title "FunctionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:IfActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:IfActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:elseAction, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:ifArgument, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:thenAction, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An IfActionUsage is an ActionUsage that specifies that the thenAction ActionUsage should be performed if the result of the ifArgument Expression is true. It may also optionally specify an elseAction ActionUsage that is performed if the result of the ifArgument is false."^^rdf:XMLLiteral ; - dcterms:title "IfActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ImportShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Import ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Import is an Relationship between its importOwningNamespace and either a Membership (for a MembershipImport) or another Namespace (for a NamespaceImport), which determines a set of Memberships that become importedMemberships of the importOwningNamespace. If isImportAll = false (the default), then only public Memberships are considered \"visible\". If isImportAll = true, then all Memberships are considered \"visible\", regardless of their declared visibility. If isRecursive = true, then visible Memberships are also recursively imported from owned sub-Namespaces."^^rdf:XMLLiteral ; - dcterms:title "ImportShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:IncludeUseCaseUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:IncludeUseCaseUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "includedUseCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:includedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:caseDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:eventOccurrence, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:performedAction, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:useCaseDefinition, - oslc_sysml_shapes:useCaseIncluded ; - dcterms:description "An IncludeUseCaseUsage is a UseCaseUsage that represents the inclusion of a UseCaseUsage by a UseCaseDefinition or UseCaseUsage. Unless it is the IncludeUseCaseUsage itself, the UseCaseUsage to be included is related to the includedUseCase by a ReferenceSubsetting Relationship. An IncludeUseCaseUsage is also a PerformActionUsage, with its useCaseIncluded as the performedAction."^^rdf:XMLLiteral ; - dcterms:title "IncludeUseCaseUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:InteractionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Interaction ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:step, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Interaction is a Behavior that is also an Association, providing a context for multiple objects that have behaviors that impact one another."^^rdf:XMLLiteral ; - dcterms:title "InteractionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:InterfaceDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:InterfaceDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:associationEnd, - oslc_sysml_shapes:connectionEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interfaceEnd, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedType, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceType, - oslc_sysml_shapes:targetType, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An InterfaceDefinition is a ConnectionDefinition all of whose ends are PortUsages, defining an interface between elements that interact through such ports."^^rdf:XMLLiteral ; - dcterms:title "InterfaceDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:InterfaceUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:InterfaceUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectionDefinition, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interfaceDefinition, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An InterfaceUsage is a Usage of an InterfaceDefinition to represent an interface connecting parts of a system through specific ports."^^rdf:XMLLiteral ; - dcterms:title "InterfaceUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:IntersectingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Intersecting ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typeIntersected ; - dcterms:description "Intersecting is a Relationship that makes its intersectingType one of the intersectingTypes of its typeIntersected."^^rdf:XMLLiteral ; - dcterms:title "IntersectingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:InvariantShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Invariant ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNegated, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An Invariant is a BooleanExpression that is asserted to have a specific Boolean result value. If isNegated = false, then the result is asserted to be true. If isNegated = true, then the result is asserted to be false."^^rdf:XMLLiteral ; - dcterms:title "InvariantShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:InvocationExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:InvocationExpression ; - oslc:property [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An InvocationExpression is an Expression each of whose input parameters are bound to the result of an argument Expression."^^rdf:XMLLiteral ; - dcterms:title "InvocationExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ItemDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ItemDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ItemDefinition is an OccurrenceDefinition of the Structure of things that may themselves be systems or parts of systems, but may also be things that are acted on by a system or parts of a system, but which do not necessarily perform actions themselves. This includes items that can be exchanged between parts of a system, such as water or electrical signals."^^rdf:XMLLiteral ; - dcterms:title "ItemDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ItemFeatureShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ItemFeature ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ItemFeature is the ownedFeature of an ItemFlow that identifies the things carried by the kinds of transfers that are instances of the ItemFlow."^^rdf:XMLLiteral ; - dcterms:title "ItemFeatureShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ItemFlowEndShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ItemFlowEnd ; - oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ItemFlowEnd is a Feature that is one of the connectorEnds giving the source or target of an ItemFlow. For ItemFlows typed by FlowTransfer or its specializations, ItemFlowEnds must have exactly one ownedFeature, which redefines Transfer::source::sourceOutput or Transfer::target::targetInput and redefines the corresponding feature of the relatedElement for its end."^^rdf:XMLLiteral ; - dcterms:title "ItemFlowEndShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ItemFlowShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ItemFlow ; - oslc:property [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interaction, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemFeature, - oslc_sysml_shapes:itemFlowEnd, - oslc_sysml_shapes:itemType, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:sourceOutputFeature, - oslc_sysml_shapes:targetInputFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ItemFlow is a Step that represents the transfer of objects or data values from one Feature to another. ItemFlows can take non-zero time to complete."^^rdf:XMLLiteral ; - dcterms:title "ItemFlowShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ItemUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ItemUsage ; - oslc:property [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ItemUsage is a ItemUsage whose definition is a Structure. Nominally, if the definition is an ItemDefinition, an ItemUsage is a ItemUsage of that ItemDefinition within a system. However, other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "ItemUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:JoinNodeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:JoinNode ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A JoinNode is a ControlNode that waits for the completion of all the predecessor Actions given by incoming Successions."^^rdf:XMLLiteral ; - dcterms:title "JoinNodeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LibraryPackageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LibraryPackage ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:filterCondition, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isStandard, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LibraryPackage is a Package that is the container for a model library. A LibraryPackage is itself a library Element as are all Elements that are directly or indirectly contained in it."^^rdf:XMLLiteral ; - dcterms:title "LibraryPackageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LifeClassShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LifeClass ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LifeClass is a Class that specializes both the Class Occurrences::Life from the Kernel Semantic Library and a single OccurrenceDefinition, and has a multiplicity of 0..1. This constrains the OccurrenceDefinition being specialized to have at most one instance that is a complete Life."^^rdf:XMLLiteral ; - dcterms:title "LifeClassShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralBooleanShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralBoolean ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The Boolean value that is the result of evaluating this LiteralBoolean."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "LiteralBoolean is a LiteralExpression that provides a Boolean value as a result. Its result parameter must have type Boolean."^^rdf:XMLLiteral ; - dcterms:title "LiteralBooleanShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralExpression ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LiteralExpression is an Expression that provides a basic DataValue as a result."^^rdf:XMLLiteral ; - dcterms:title "LiteralExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralInfinityShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralInfinity ; - oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LiteralInfinity is a LiteralExpression that provides the positive infinity value (*). It's result must have the type Positive."^^rdf:XMLLiteral ; - dcterms:title "LiteralInfinityShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralIntegerShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralInteger ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The Integer value that is the result of evaluating this LiteralInteger."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LiteralInteger is a LiteralExpression that provides an Integer value as a result. Its result parameter must have the type Integer."^^rdf:XMLLiteral ; - dcterms:title "LiteralIntegerShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralRationalShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralRational ; - oslc:property [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The value whose rational approximation is the result of evaluating this LiteralRational."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LiteralRational is a LiteralExpression that provides a Rational value as a result. Its result parameter must have the type Rational."^^rdf:XMLLiteral ; - dcterms:title "LiteralRationalShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LiteralStringShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LiteralString ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "value" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:value ; - oslc:readOnly false ; - dcterms:description "The String value that is the result of evaluating this LiteralString."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LiteralString is a LiteralExpression that provides a String value as a result. Its result parameter must have the type String."^^rdf:XMLLiteral ; - dcterms:title "LiteralStringShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:LoopActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:LoopActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:bodyAction, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A LoopActionUsage is an ActionUsage that specifies that its bodyAction should be performed repeatedly. Its subclasses WhileLoopActionUsage and ForLoopActionUsage provide different ways to determine how many times the bodyAction should be performed."^^rdf:XMLLiteral ; - dcterms:title "LoopActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MembershipExposeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MembershipExpose ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Membership to be imported."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MembershipExpose is an Expose that exposes a specific importedMembership and, if isRecursive = true, additional Memberships recursively.."^^rdf:XMLLiteral ; - dcterms:title "MembershipExposeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MembershipImportShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MembershipImport ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Membership to be imported."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MembershipImport is an Import that imports its importedMembership into the importOwningNamespace. If isRecursive = true and the memberElement of the importedMembership is a Namespace, then the equivalent of a recursive NamespaceImport is also performed on that Namespace."^^rdf:XMLLiteral ; - dcterms:title "MembershipImportShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Membership ; - oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Membership is a Relationship between a Namespace and an Element that indicates the Element is a member of (i.e., is contained in) the Namespace. Any memberNames specify how the memberElement is identified in the Namespace and the visibility specifies whether or not the memberElement is publicly visible from outside the Namespace."^^rdf:XMLLiteral ; - dcterms:title "MembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MergeNodeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MergeNode ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MergeNode is a ControlNode that asserts the merging of its incoming Successions. A MergeNode may have at most one outgoing Successions."^^rdf:XMLLiteral ; - dcterms:title "MergeNodeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MetaclassShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Metaclass ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Metaclass is a Structure used to type MetadataFeatures."^^rdf:XMLLiteral ; - dcterms:title "MetaclassShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MetadataAccessExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MetadataAccessExpression ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedElement, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MetadataAccessExpression is an Expression whose result is a sequence of instances of Metaclasses representing all the MetadataFeature annotations of the referencedElement. In addition, the sequence includes an instance of the reflective Metaclass corresponding to the MOF class of the referencedElement, with values for all the abstract syntax properties of the referencedElement."^^rdf:XMLLiteral ; - dcterms:title "MetadataAccessExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MetadataDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MetadataDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MetadataDefinition is an ItemDefinition that is also a Metaclass."^^rdf:XMLLiteral ; - dcterms:title "MetadataDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MetadataFeatureShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MetadataFeature ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:metaclass, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MetadataFeature is a Feature that is an AnnotatingElement used to annotate another Element with metadata. It is typed by a Metaclass. All its ownedFeatures must redefine features of its metaclass and any feature bindings must be model-level evaluable."^^rdf:XMLLiteral ; - dcterms:title "MetadataFeatureShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MetadataUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MetadataUsage ; - oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:metaclass, - oslc_sysml_shapes:metadataDefinition, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A MetadataUsage is a Usage and a MetadataFeature, used to annotate other Elements in a system model with metadata. As a MetadataFeature, its type must be a Metaclass, which will nominally be a MetadataDefinition. However, any kernel Metaclass is also allowed, to permit use of Metaclasses from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "MetadataUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MultiplicityRangeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:MultiplicityRange ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:bound, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:lowerBound, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:upperBound ; - dcterms:description "A MultiplicityRange is a Multiplicity whose value is defined to be the (inclusive) range of natural numbers given by the result of a lowerBound Expression and the result of an upperBound Expression. The result of these Expressions shall be of type Natural. If the result of the upperBound Expression is the unbounded value *, then the specified range includes all natural numbers greater than or equal to the lowerBound value. If no lowerBound Expression, then the default is that the lower bound has the same value as the upper bound, except if the upperBound evaluates to *, in which case the default for the lower bound is 0."^^rdf:XMLLiteral ; - dcterms:title "MultiplicityRangeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:MultiplicityShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Multiplicity ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description """A Multiplicity is a Feature whose co-domain is a set of natural numbers giving the allowed cardinalities of each typeWithMultiplicity. The cardinality of a Type is defined as follows, depending on whether the Type is a Classifier or Feature. -."""^^rdf:XMLLiteral ; - dcterms:title "MultiplicityShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:NamespaceExposeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:NamespaceExpose ; - oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:importedNamespace, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A NamespaceExpose is an Expose Relationship that exposes the Memberships of a specific importedNamespace and, if isRecursive = true, additional Memberships recursively."^^rdf:XMLLiteral ; - dcterms:title "NamespaceExposeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:NamespaceImportShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:NamespaceImport ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:importOwningNamespace, - oslc_sysml_shapes:importedElement, - oslc_sysml_shapes:importedNamespace, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isImportAll, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isRecursive, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A NamespaceImport is an Import that imports Memberships from its importedNamespace into the importOwningNamespace. If isRecursive = false, then only the visible Memberships of the importedNamespace are imported. If isRecursive = true, then, in addition, Memberships are recursively imported from any ownedMembers of the importedNamespace that are Namespaces."^^rdf:XMLLiteral ; - dcterms:title "NamespaceImportShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:NamespaceShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Namespace ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Namespace is an Element that contains other Elements, known as its members, via Membership Relationships with those Elements. The members of a Namespace may be owned by the Namespace, aliased in the Namespace, or imported into the Namespace via Import Relationships."^^rdf:XMLLiteral ; - dcterms:title "NamespaceShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:NullExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:NullExpression ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A NullExpression is an Expression that results in a null value."^^rdf:XMLLiteral ; - dcterms:title "NullExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ObjectiveMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ObjectiveMembership ; - oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedObjectiveRequirement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An ObjectiveMembership is a FeatureMembership that indicates that its ownedObjectiveRequirement is the objective RequirementUsage for its owningType, which must be a CaseDefinition or CaseUsage."^^rdf:XMLLiteral ; - dcterms:title "ObjectiveMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:OccurrenceDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:OccurrenceDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An OccurrenceDefinition is a Definition of a Class of individuals that have an independent life over time and potentially an extent over space. This includes both structural things and behaviors that act on such structures."^^rdf:XMLLiteral ; - dcterms:title "OccurrenceDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:OccurrenceUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:OccurrenceUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An OccurrenceUsage is a Usage whose types are all Classes. Nominally, if a type is an OccurrenceDefinition, an OccurrenceUsage is a Usage of that OccurrenceDefinition within a system. However, other types of Kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries."^^rdf:XMLLiteral ; - dcterms:title "OccurrenceUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:OperatorExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:OperatorExpression ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:operator, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An OperatorExpression is an InvocationExpression whose function is determined by resolving its operator in the context of one of the standard packages from the Kernel Function Library."^^rdf:XMLLiteral ; - dcterms:title "OperatorExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:OwningMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:OwningMembership ; - oslc:property [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "An OwningMembership is a Membership that owns its memberElement as a ownedRelatedElement. The ownedMemberElement becomes an ownedMember of the membershipOwningNamespace."^^rdf:XMLLiteral ; - dcterms:title "OwningMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PackageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Package ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:filterCondition, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Package is a Namespace used to group Elements, without any instance-level semantics. It may have one or more model-level evaluable filterCondition Expressions used to filter its importedMemberships. Any imported member must meet all of the filterConditions."^^rdf:XMLLiteral ; - dcterms:title "PackageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ParameterMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ParameterMembership ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberParameter, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ParameterMembership is a FeatureMembership that identifies its memberFeature as a parameter, which is always owned, and must have a direction. A ParameterMembership must be owned by a Behavior or a Step."^^rdf:XMLLiteral ; - dcterms:title "ParameterMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PartDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PartDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PartDefinition is an ItemDefinition of a Class of systems or parts of systems. Note that all parts may be considered items for certain purposes, but not all items are parts that can perform actions within a system."^^rdf:XMLLiteral ; - dcterms:title "PartDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PartUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PartUsage ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PartUsage is a usage of a PartDefinition to represent a system or a part of a system. At least one of the itemDefinitions of the PartUsage must be a PartDefinition."^^rdf:XMLLiteral ; - dcterms:title "PartUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PerformActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PerformActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:eventOccurrence, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:performedAction, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PerformActionUsage is an ActionUsage that represents the performance of an ActionUsage. Unless it is the PerformActionUsage itself, the ActionUsage to be performed is related to the PerformActionUsage by a ReferenceSubsetting relationship. A PerformActionUsage is also an EventOccurrenceUsage, with its performedAction as the eventOccurrence."^^rdf:XMLLiteral ; - dcterms:title "PerformActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PortConjugationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PortConjugation ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The conjugatedType of this Conjugation that is also its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "originalPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:originalPortDefinition ; - oslc:range oslc_sysml:PortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PortDefinition being conjugated."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConjugatedPortDefinition that is conjugate to the originalPortDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:conjugatedType, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:originalType, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PortConjugation is a Conjugation Relationship between a PortDefinition and its corresponding ConjugatedPortDefinition. As a result of this Relationship, the ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition."^^rdf:XMLLiteral ; - dcterms:title "PortConjugationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PortDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PortDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "conjugatedPortDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:conjugatedPortDefinition ; - oslc:range oslc_sysml:ConjugatedPortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The that is conjugate to this PortDefinition.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PortDefinition defines a point at which external entities can connect to and interact with a system or part of a system. Any ownedUsages of a PortDefinition, other than PortUsages, must not be composite."^^rdf:XMLLiteral ; - dcterms:title "PortDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PortUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:PortUsage ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "portDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:portDefinition ; - oslc:range oslc_sysml:PortDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The occurrenceDefinitions of this PortUsage, which must all be PortDefinitions.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A PortUsage is a usage of a PortDefinition. A PortUsage itself as well as all its nestedUsages must be referential (non-composite)."^^rdf:XMLLiteral ; - dcterms:title "PortUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:PredicateShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Predicate ; - oslc:property [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Predicate is a Function whose result parameter has type Boolean and multiplicity 1..1."^^rdf:XMLLiteral ; - dcterms:title "PredicateShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RedefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Redefinition ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:redefinedFeature, - oslc_sysml_shapes:redefiningFeature, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:subsettedFeature, - oslc_sysml_shapes:subsettingFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Redefinition is a kind of Subsetting that requires the redefinedFeature and the redefiningFeature to have the same values (on each instance of the domain of the redefiningFeature). This means any restrictions on the redefiningFeature, such as type or multiplicity, also apply to the redefinedFeature (on each instance of the domain of the redefiningFeature), and vice versa. The redefinedFeature might have values for instances of the domain of the redefiningFeature, but only as instances of the domain of the redefinedFeature that happen to also be instances of the domain of the redefiningFeature. This is supported by the constraints inherited from Subsetting on the domains of the redefiningFeature and redefinedFeature. However, these constraints are narrowed for Redefinition to require the owningTypes of the redefiningFeature and redefinedFeature to be different and the redefinedFeature to not be inherited into the owningNamespace of the redefiningFeature.This enables the redefiningFeature to have the same name as the redefinedFeature, if desired."^^rdf:XMLLiteral ; - dcterms:title "RedefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ReferenceSubsettingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ReferenceSubsetting ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedFeature, - oslc_sysml_shapes:referencingFeature, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:subsettedFeature, - oslc_sysml_shapes:subsettingFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "ReferenceSubsetting is a kind of Subsetting in which the referencedFeature is syntactically distinguished from other Features subsetted by the referencingFeature. ReferenceSubsetting has the same semantics as Subsetting, but the referenceFeature may have a special purpose relative to the referencingFeature. For instance, ReferenceSubsetting is used to identify the relatedFeatures of a Connector."^^rdf:XMLLiteral ; - dcterms:title "ReferenceSubsettingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ReferenceUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ReferenceUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ReferenceUsage is a Usage that specifies a non-compositional (isComposite = false) reference to something. The definition of a ReferenceUsage can be any kind of Classifier, with the default being the top-level Classifier Base::Anything from the Kernel Semantic Library. This allows the specification of a generic reference without distinguishing if the thing referenced is an attribute value, item, action, etc."^^rdf:XMLLiteral ; - dcterms:title "ReferenceUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RelationshipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Relationship ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Relationship is an Element that relates other Element. Some of its relatedElements may be owned, in which case those ownedRelatedElements will be deleted from a model if their owningRelationship is. A Relationship may also be owned by another Element, in which case the ownedRelatedElements of the Relationship are also considered to be transitively owned by the owningRelatedElement of the Relationship."^^rdf:XMLLiteral ; - dcterms:title "RelationshipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RenderingDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RenderingDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:rendering, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RenderingDefinition is a PartDefinition that defines a specific rendering of the content of a model view (e.g., symbols, style, layout, etc.)."^^rdf:XMLLiteral ; - dcterms:title "RenderingDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RenderingUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RenderingUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:renderingDefinition, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RenderingUsage is the usage of a RenderingDefinition to specify the rendering of a specific model view to produce a physical view artifact."^^rdf:XMLLiteral ; - dcterms:title "RenderingUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RequirementConstraintMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RequirementConstraintMembership ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedConstraint, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RequirementConstraintMembership is a FeatureMembership for an assumed or required ConstraintUsage of a RequirementDefinition or RequirementUsage.."^^rdf:XMLLiteral ; - dcterms:title "RequirementConstraintMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RequirementDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RequirementDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RequirementDefinition is a ConstraintDefinition that defines a requirement used in the context of a specification as a constraint that a valid solution must satisfy. The specification is relative to a specified subject, possibly in collaboration with one or more external actors."^^rdf:XMLLiteral ; - dcterms:title "RequirementDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RequirementUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RequirementUsage ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:requirementDefinition, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RequirementUsage is a Usage of a RequirementDefinition."^^rdf:XMLLiteral ; - dcterms:title "RequirementUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:RequirementVerificationMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:RequirementVerificationMembership ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "verifiedRequirement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:verifiedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description " The RequirementUsage that is identified as being verified. It is the referencedConstraint of the RequirementVerificationMembership considered as a RequirementConstraintMembership, which must be a RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned RequirementUsage that acts as the ownedConstraint for this RequirementVerificationMembership. This will either be the verifiedRequirement, or it will subset the verifiedRequirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedConstraint, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A RequirementVerificationMembership is a RequirementConstraintMembership used in the objective of a VerificationCase to identify a RequirementUsage that is verified by the VerificationCase."^^rdf:XMLLiteral ; - dcterms:title "RequirementVerificationMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ResultExpressionMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ResultExpressionMembership ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedResultExpression, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ResultExpressionMembership is a FeatureMembership that indicates that the ownedResultExpression provides the result values for the Function or Expression that owns it. The owning Function or Expression must contain a BindingConnector between the result parameter of the ownedResultExpression and the result parameter of the owning Function or Expression."^^rdf:XMLLiteral ; - dcterms:title "ResultExpressionMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ReturnParameterMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ReturnParameterMembership ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberParameter, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ReturnParameterMembership is a ParameterMembership that indicates that the ownedMemberParameter is the result parameter of a Function or Expression. The direction of the ownedMemberParameter must be out."^^rdf:XMLLiteral ; - dcterms:title "ReturnParameterMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SatisfyRequirementUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SatisfyRequirementUsage ; - oslc:property [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:assertedConstraint, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNegated, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:requirementDefinition, - oslc_sysml_shapes:satisfiedRequirement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:satisfyingFeature, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A SatisfyRequirementUsage is an AssertConstraintUsage that asserts, by default, that a satisfied RequirementUsage is true for a specific satisfyingFeature, or, if isNegated = true, that the RequirementUsage is false. The satisfied RequirementUsage is related to the SatisfyRequirementUsage by a ReferenceSubsetting Relationship."^^rdf:XMLLiteral ; - dcterms:title "SatisfyRequirementUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SelectExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SelectExpression ; - oslc:property [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:operator, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A SelectExpression is an OperatorExpression whose operator is \"select\", which resolves to the Function ControlFunctions::select from the Kernel Functions Library."^^rdf:XMLLiteral ; - dcterms:title "SelectExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SendActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SendActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "receiverArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:receiverArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the receiver input parameter of this SendActionUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "payloadArgument" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:payloadArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the payload input parameter of this SendActionUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:senderArgument, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A SendActionUsage is an ActionUsage that specifies the sending of a payload given by the result of its payloadArgument Expression via a MessageTransfer whose source is given by the result of the senderArgument Expression and whose target is given by the result of the receiverArgument Expression. If no senderArgument is provided, the default is the this context for the action. If no receiverArgument is given, then the receiver is to be determined by, e.g., outgoing Connections from the sender."^^rdf:XMLLiteral ; - dcterms:title "SendActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SpecializationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Specialization ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Specialization is a Relationship between two Types that requires all instances of the specific type to also be instances of the general Type (i.e., the set of instances of the specific Type is a subset of those of the general Type, which might be the same set)."^^rdf:XMLLiteral ; - dcterms:title "SpecializationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StakeholderMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:StakeholderMembership ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberParameter, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedStakeholderParameter, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A StakeholderMembership is a ParameterMembership that identifies a PartUsage as a stakeholderParameter of a RequirementDefinition or RequirementUsage, which specifies a role played by an entity with concerns framed by the owningType."^^rdf:XMLLiteral ; - dcterms:title "StakeholderMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StateDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:StateDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "entryAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:entryAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateDefinition to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateDefinition to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "doAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:doAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateDefinition to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isParallel" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; - oslc:readOnly false ; - dcterms:description "Whether the ownedStates of this StateDefinition are to all be performed in parallel. If true, none of the ownedActions (which includes ownedStates) may have any incoming or outgoing Transitions. If false, only one ownedState may be performed at a time."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:state, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A StateDefinition is the Definition of the Behavior of a system or part of a system in a certain state condition."^^rdf:XMLLiteral ; - dcterms:title "StateDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StateSubactionMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:StateSubactionMembership ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage that is the ownedMemberFeature of this StateSubactionMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether this StateSubactionMembership is for an entry, do or exit ActionUsage.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A StateSubactionMembership is a FeatureMembership for an entry, do or exit ActionUsage of a StateDefinition or StateUsage.."^^rdf:XMLLiteral ; - dcterms:title "StateSubactionMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StateUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:StateUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "doAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:doAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "entryAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:entryAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "exitAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:exitAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isParallel" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isParallel ; - oslc:readOnly false ; - dcterms:description "Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:stateDefinition, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description """A StateUsage is an ActionUsage that is nominally the Usage of a StateDefinition. However, other kinds of kernel Behaviors are also allowed as types, to permit use of Behaviors -."""^^rdf:XMLLiteral ; - dcterms:title "StateUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StepShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Step ; - oslc:property [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Step is a Feature that is typed by one or more Behaviors. Steps may be used by one Behavior to coordinate the performance of other Behaviors, supporting a steady refinement of behavioral descriptions. Steps can be ordered in time and can be connected using ItemFlows to specify things flowing between their parameters."^^rdf:XMLLiteral ; - dcterms:title "StepShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:StructureShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Structure ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Structure is a Class of objects in the modeled universe that are primarily structural in nature. While such an object is not itself behavioral, it may be involved in and acted on by Behaviors, and it may be the performer of some of them."^^rdf:XMLLiteral ; - dcterms:title "StructureShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SubclassificationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Subclassification ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningClassifier, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:subclassifier, - oslc_sysml_shapes:superclassifier, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Subclassification is Specialization in which both the specific and general Types are Classifier. This means all instances of the specific Classifier are also instances of the general Classifier."^^rdf:XMLLiteral ; - dcterms:title "SubclassificationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SubjectMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SubjectMembership ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberParameter, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSubjectParameter, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A SubjectMembership is a ParameterMembership that indicates that its ownedSubjectParameter is the subject of its owningType. The owningType of a SubjectMembership must be a RequirementDefinition, RequirementUsage, CaseDefinition, or CaseUsage."^^rdf:XMLLiteral ; - dcterms:title "SubjectMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SubsettingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Subsetting ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A subsettingFeature that is also the owningRelatedElement of this Subsetting."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:general, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:specific, - oslc_sysml_shapes:subsettedFeature, - oslc_sysml_shapes:subsettingFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "Subsetting is Specialization in which the specific and general Types are Features. This means all values of the subsettingFeature (on instances of its domain, i.e., the intersection of its featuringTypes) are values of the subsettedFeature on instances of its domain. To support this the domain of the subsettingFeature must be the same or specialize (at least indirectly) the domain of the subsettedFeature (via Specialization), and the co-domain (intersection of the types) of the subsettingFeature must specialize the co-domain of the subsettedFeature."^^rdf:XMLLiteral ; - dcterms:title "SubsettingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SuccessionAsUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SuccessionAsUsage ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:effectStep, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:transitionStep, - oslc_sysml_shapes:triggerStep, - oslc_sysml_shapes:type ; - dcterms:description "A SuccessionAsUsage is both a ConnectorAsUsage and a Succession."^^rdf:XMLLiteral ; - dcterms:title "SuccessionAsUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SuccessionFlowConnectionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SuccessionFlowConnectionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:connectionDefinition, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:effectStep, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:flowConnectionDefinition, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interaction, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:itemFeature, - oslc_sysml_shapes:itemFlowEnd, - oslc_sysml_shapes:itemType, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:sourceOutputFeature, - oslc_sysml_shapes:targetInputFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:transitionStep, - oslc_sysml_shapes:triggerStep, - oslc_sysml_shapes:type ; - dcterms:description "A SuccessionFlowConnectionUsage is a FlowConnectionUsage that is also a SuccessionItemFlow."^^rdf:XMLLiteral ; - dcterms:title "SuccessionFlowConnectionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SuccessionItemFlowShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:SuccessionItemFlow ; - oslc:property [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:effectStep, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:interaction, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemFeature, - oslc_sysml_shapes:itemFlowEnd, - oslc_sysml_shapes:itemType, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:sourceOutputFeature, - oslc_sysml_shapes:targetInputFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:transitionStep, - oslc_sysml_shapes:triggerStep, - oslc_sysml_shapes:type ; - dcterms:description "A SuccessionItemFlow is an ItemFlow that also provides temporal ordering. It classifies Transfers that cannot start until the source Occurrence has completed and that must complete before the target Occurrence can start."^^rdf:XMLLiteral ; - dcterms:title "SuccessionItemFlowShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:SuccessionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Succession ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "targetFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Expressions that must evaluate to true before the transitionStep can occur."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:association, - oslc_sysml_shapes:connectorEnd, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:effectStep, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:relatedFeature, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:sourceFeature, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:transitionStep, - oslc_sysml_shapes:triggerStep, - oslc_sysml_shapes:type ; - dcterms:description "A Succession is a binary Connector that requires its relatedFeatures to happen separately in time."^^rdf:XMLLiteral ; - dcterms:title "SuccessionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TerminateActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TerminateActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:terminatedOccurrenceArgument, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A TerminateActionUsage is an ActionUsage that directly or indirectly specializes the ActionDefinition TerminateAction from the Systems Model Library, which causes a given terminatedOccurrence to end during its performance. By default, the terminatedOccurrence is the featuring instance (that) of the performance of the TerminateActionUsage, generally the performance of its immediately containing ActionDefinition or ActionUsage."^^rdf:XMLLiteral ; - dcterms:title "TerminateActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TextualRepresentationShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TextualRepresentation ; - oslc:property [ a oslc:Property ; - oslc:name "body" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:body ; - oslc:readOnly false ; - dcterms:description "The textual representation of the representedElement in the given language."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "annotatedElement" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:annotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:annotation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:language, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotatingRelationship, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:representedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A TextualRepresentation is an AnnotatingElement whose body represents the representedElement in a given language. The representedElement must be the owner of the TextualRepresentation. The named language can be a natural language, in which case the body is an informal representation, or an artificial language, in which case the body is expected to be a formal, machine-parsable representation."^^rdf:XMLLiteral ; - dcterms:title "TextualRepresentationShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TransitionFeatureMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TransitionFeatureMembership ; - oslc:property [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Whether this TransitionFeatureMembership is for a trigger, guard or effect."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:transitionFeature, - oslc_sysml_shapes:type ; - dcterms:description "A TransitionFeatureMembership is a FeatureMembership for a trigger, guard or effect of a TransitionUsage, whose transitionFeature is a AcceptActionUsage, Boolean-valued Expression or ActionUsage, depending on its kind. ."^^rdf:XMLLiteral ; - dcterms:title "TransitionFeatureMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TransitionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TransitionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "guardExpression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:guardExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions that define the guards of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = guard, which must all be Expressions."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target ActionUsage of this TransitionUsage, which is the targetFeature of the succession for the TransitionUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The source ActionUsage of this TransitionUsage, which becomes the source of the succession for the TransitionUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:effectAction, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:succession, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:triggerAction, - oslc_sysml_shapes:type ; - dcterms:description "A TransitionUsage is an ActionUsage representing a triggered transition between ActionUsages or StateUsages. When triggered by a triggerAction, when its guardExpression is true, the TransitionUsage asserts that its source is exited, then its effectAction (if any) is performed, and then its target is entered."^^rdf:XMLLiteral ; - dcterms:title "TransitionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TriggerInvocationExpressionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TriggerInvocationExpression ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "kind" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:kind ; - oslc:readOnly false ; - dcterms:description "Indicates which of the Functions from the Triggers model in the Kernel Semantic Library is to be invoked by this TriggerInvocationExpression."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:argument, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:operand, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A TriggerInvocationExpression is an InvocationExpression that invokes one of the trigger Functions from the Kernel Semantic Library Triggers package, as indicated by its kind."^^rdf:XMLLiteral ; - dcterms:title "TriggerInvocationExpressionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TypeFeaturingShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:TypeFeaturing ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType. It is the target of the TypeFeaturing."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureOfType, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningFeatureOfType, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A TypeFeaturing is a Featuring Relationship in which the featureOfType is the source and the featuringType is the target."^^rdf:XMLLiteral ; - dcterms:title "TypeFeaturingShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:TypeShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Type ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Type is a Namespace that is the most general kind of Element supporting the semantics of classification. A Type may be a Classifier or a Feature, defining conditions on what is classified by the Type (see also the description of isSufficient)."^^rdf:XMLLiteral ; - dcterms:title "TypeShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:UnioningShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Unioning ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type that partly determines interpretations of typeUnioned, as described in Type::unioningType."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:typeUnioned ; - dcterms:description "Unioning is a Relationship that makes its unioningType one of the unioningTypes of its typeUnioned."^^rdf:XMLLiteral ; - dcterms:title "UnioningShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:UsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:Usage ; - oslc:property [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A Usage is a usage of a Definition. A Usage may only be an ownedFeature of a Definition or another Usage."^^rdf:XMLLiteral ; - dcterms:title "UsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:UseCaseDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:UseCaseDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "includedUseCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:includedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are included by this UseCaseDefinition, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseDefinition.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A UseCaseDefinition is a CaseDefinition that specifies a set of actions performed by its subject, in interaction with one or more actors external to the subject. The objective is to yield an observable result that is of value to one or more of the actors."^^rdf:XMLLiteral ; - dcterms:title "UseCaseDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:UseCaseUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:UseCaseUsage ; - oslc:property [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "includedUseCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:includedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:caseDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:useCaseDefinition ; - dcterms:description "A UseCaseUsage is a Usage of a UseCaseDefinition."^^rdf:XMLLiteral ; - dcterms:title "UseCaseUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:VariantMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:VariantMembership ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedVariantUsage, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A VariantMembership is a Membership between a variation point Definition or Usage and a Usage that represents a variant in the context of that variation. The membershipOwningNamespace for the VariantMembership must be either a Definition or a Usage with isVariation = true."^^rdf:XMLLiteral ; - dcterms:title "VariantMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:VerificationCaseDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:VerificationCaseDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "verifiedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:verifiedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages verified by this VerificationCaseDefinition, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseDefinition that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "action" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:action ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:calculation, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A VerificationCaseDefinition is a CaseDefinition for the purpose of verification of the subject of the case against its requirements."^^rdf:XMLLiteral ; - dcterms:title "VerificationCaseDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:VerificationCaseUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:VerificationCaseUsage ; - oslc:property [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "verifiedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:verifiedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages verified by this VerificationCaseUsage, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "objectiveRequirement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:objectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage representing the objective of this CaseUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this CaseUsage that represent actors involved in the case."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this CaseUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:calculationDefinition, - oslc_sysml_shapes:caseDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:verificationCaseDefinition ; - dcterms:description "A VerificationCaseUsage is a Usage of a VerificationCaseDefinition."^^rdf:XMLLiteral ; - dcterms:title "VerificationCaseUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ViewDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ViewDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewRendering" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsage to be used to render views defined by this ViewDefinition, which is the referencedRendering of the ViewRenderingMembership of the ViewDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "satisfiedViewpoint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The composite ownedRequirements of this ViewDefinition that are ViewpointUsages for viewpoints satisfied by the ViewDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewCondition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewCondition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions related to this ViewDefinition by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:view ; - dcterms:description "A ViewDefinition is a PartDefinition that specifies how a view artifact is constructed to satisfy a viewpoint. It specifies a viewConditions to define the model content to be presented and a viewRendering to define how the model content is presented."^^rdf:XMLLiteral ; - dcterms:title "ViewDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ViewRenderingMembershipShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ViewRenderingMembership ; - oslc:property [ a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:source ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements from which this Relationship is considered to be directed.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "visibility" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:visibility ; - oslc:readOnly false ; - dcterms:description "Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "target" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:target ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements to which this Relationship is considered to be directed."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned RenderingUsage that is either itself the referencedRendering or subsets the referencedRendering."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that features the featureOfType.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that owns this FeatureMembership."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:external, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isImplied, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:memberElement, - oslc_sysml_shapes:memberElementId, - oslc_sysml_shapes:memberName, - oslc_sysml_shapes:memberShortName, - oslc_sysml_shapes:membershipOwningNamespace, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:name, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedMemberElement, - oslc_sysml_shapes:ownedMemberElementId, - oslc_sysml_shapes:ownedMemberFeature, - oslc_sysml_shapes:ownedMemberName, - oslc_sysml_shapes:ownedMemberShortName, - oslc_sysml_shapes:ownedRelatedElement, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelatedElement, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:referencedRendering, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:relatedElement, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ViewRenderingMembership is a FeatureMembership that identifies the viewRendering of a ViewDefinition or ViewUsage.."^^rdf:XMLLiteral ; - dcterms:title "ViewRenderingMembershipShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ViewUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ViewUsage ; - oslc:property [ a oslc:Property ; - oslc:name "viewRendering" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsage to be used to render views defined by this ViewUsage, which is the referencedRendering of the ViewRenderingMembership of the ViewUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewCondition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewCondition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions related to this ViewUsage by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "satisfiedViewpoint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:satisfiedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The nestedRequirements of this ViewUsage that are ViewpointUsages for (additional) viewpoints satisfied by the ViewUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:exposedElement, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:itemDefinition, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:partDefinition, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:viewDefinition ; - dcterms:description "A ViewUsage is a usage of a ViewDefinition to specify the generation of a view of the members of a collection of exposedNamespaces. The ViewUsage can satisfy more viewpoints than its definition, and it can specialize the viewRendering specified by its definition."^^rdf:XMLLiteral ; - dcterms:title "ViewUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ViewpointDefinitionShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ViewpointDefinition ; - oslc:property [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "viewpointStakeholder" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewpointStakeholder ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsages that identify the stakeholders with concerns framed by this ViewpointDefinition, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Definition (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementDefinition that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent stakeholders for th requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Definition that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "ownedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceDefinition is constrained to represent single individual."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementDefinition that represent actors involved in the requirement."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:expression, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:lifeClass, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAction, - oslc_sysml_shapes:ownedAllocation, - oslc_sysml_shapes:ownedAnalysisCase, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedAttribute, - oslc_sysml_shapes:ownedCalculation, - oslc_sysml_shapes:ownedCase, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedConnection, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedEnumeration, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedFlow, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedInterface, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedItem, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedMetadata, - oslc_sysml_shapes:ownedOccurrence, - oslc_sysml_shapes:ownedPart, - oslc_sysml_shapes:ownedPort, - oslc_sysml_shapes:ownedReference, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedState, - oslc_sysml_shapes:ownedSubclassification, - oslc_sysml_shapes:ownedTransition, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:ownedUsage, - oslc_sysml_shapes:ownedUseCase, - oslc_sysml_shapes:ownedVerificationCase, - oslc_sysml_shapes:ownedView, - oslc_sysml_shapes:ownedViewpoint, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:step, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type ; - dcterms:description "A ViewpointDefinition is a RequirementDefinition that specifies one or more stakeholder concerns that are to be satisfied by creating a view of a model."^^rdf:XMLLiteral ; - dcterms:title "ViewpointDefinitionShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:ViewpointUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:ViewpointUsage ; - oslc:property [ a oslc:Property ; - oslc:name "viewpointStakeholder" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:viewpointStakeholder ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsages that identify the stakeholders with concerns framed by this ViewpointUsage, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "text" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:text ; - oslc:readOnly false ; - dcterms:description "An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage.."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "result" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:result ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "reqId" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:reqId ; - oslc:readOnly false ; - dcterms:description "An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isModelLevelEvaluable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isModelLevelEvaluable ; - oslc:readOnly false ; - dcterms:description "Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "assumedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:assumedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "actorParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent actors involved in the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "requiredConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:requiredConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "framedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:framedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "stakeholderParameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this RequirementUsage that represent stakeholders for the requirement."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "subjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameter of this RequirementUsage that represents its subject."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:constraintDefinition, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:function, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:predicate, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:requirementDefinition, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:viewpointDefinition ; - dcterms:description "A ViewpointUsage is a Usage of a ViewpointDefinition."^^rdf:XMLLiteral ; - dcterms:title "ViewpointUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:WhileLoopActionUsageShape a oslc:ResourceShape ; - oslc:describes oslc_sysml:WhileLoopActionUsage ; - oslc:property [ a oslc:Property ; - oslc:name "isIndividual" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isIndividual ; - oslc:readOnly false ; - dcterms:description "Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "parameter" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:parameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "chainingFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:chainingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "directedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this Usage that are directedFeatures."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "owningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the owningType of the owningFeatureMembership of this Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variantMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variantMembership ; - oslc:range oslc_sysml:VariantMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "importedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:importedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Memberships in this Namespace that result from the ownedImports of this Namespace."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "variant" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:variant ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:type ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "unioningType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:unioningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "intersectingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:intersectingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "usage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:usage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are features of this Usage (not necessarily owned)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "differencingType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:differencingType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex)."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "feature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:feature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the featureMemberships of this Type."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "featuringType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featuringType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature."^^rdf:XMLLiteral ], - [ a oslc:Property ; - oslc:name "isVariation" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isVariation ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships."^^rdf:XMLLiteral ], - oslc_sysml_shapes:actionDefinition, - oslc_sysml_shapes:aliasIds, - oslc_sysml_shapes:behavior, - oslc_sysml_shapes:bodyAction, - oslc_sysml_shapes:contributor, - oslc_sysml_shapes:created, - oslc_sysml_shapes:creator, - oslc_sysml_shapes:dctype, - oslc_sysml_shapes:declaredName, - oslc_sysml_shapes:declaredShortName, - oslc_sysml_shapes:definition, - oslc_sysml_shapes:derives, - oslc_sysml_shapes:description, - oslc_sysml_shapes:directedFeature, - oslc_sysml_shapes:direction, - oslc_sysml_shapes:documentation, - oslc_sysml_shapes:elaborates, - oslc_sysml_shapes:elementId, - oslc_sysml_shapes:endFeature, - oslc_sysml_shapes:endOwningType, - oslc_sysml_shapes:external, - oslc_sysml_shapes:featureMembership, - oslc_sysml_shapes:featureTarget, - oslc_sysml_shapes:identifier, - oslc_sysml_shapes:individualDefinition, - oslc_sysml_shapes:inheritedFeature, - oslc_sysml_shapes:inheritedMembership, - oslc_sysml_shapes:input, - oslc_sysml_shapes:instanceShape, - oslc_sysml_shapes:isAbstract, - oslc_sysml_shapes:isComposite, - oslc_sysml_shapes:isConjugated, - oslc_sysml_shapes:isDerived, - oslc_sysml_shapes:isEnd, - oslc_sysml_shapes:isImpliedIncluded, - oslc_sysml_shapes:isLibraryElement, - oslc_sysml_shapes:isNonunique, - oslc_sysml_shapes:isOrdered, - oslc_sysml_shapes:isPortion, - oslc_sysml_shapes:isReadOnly, - oslc_sysml_shapes:isReference, - oslc_sysml_shapes:isSufficient, - oslc_sysml_shapes:isUnique, - oslc_sysml_shapes:member, - oslc_sysml_shapes:membership, - oslc_sysml_shapes:modified, - oslc_sysml_shapes:multiplicity, - oslc_sysml_shapes:name, - oslc_sysml_shapes:nestedAction, - oslc_sysml_shapes:nestedAllocation, - oslc_sysml_shapes:nestedAnalysisCase, - oslc_sysml_shapes:nestedAttribute, - oslc_sysml_shapes:nestedCalculation, - oslc_sysml_shapes:nestedCase, - oslc_sysml_shapes:nestedConcern, - oslc_sysml_shapes:nestedConnection, - oslc_sysml_shapes:nestedConstraint, - oslc_sysml_shapes:nestedEnumeration, - oslc_sysml_shapes:nestedFlow, - oslc_sysml_shapes:nestedInterface, - oslc_sysml_shapes:nestedItem, - oslc_sysml_shapes:nestedMetadata, - oslc_sysml_shapes:nestedOccurrence, - oslc_sysml_shapes:nestedPart, - oslc_sysml_shapes:nestedPort, - oslc_sysml_shapes:nestedReference, - oslc_sysml_shapes:nestedRendering, - oslc_sysml_shapes:nestedRequirement, - oslc_sysml_shapes:nestedState, - oslc_sysml_shapes:nestedTransition, - oslc_sysml_shapes:nestedUsage, - oslc_sysml_shapes:nestedUseCase, - oslc_sysml_shapes:nestedVerificationCase, - oslc_sysml_shapes:nestedView, - oslc_sysml_shapes:nestedViewpoint, - oslc_sysml_shapes:occurrenceDefinition, - oslc_sysml_shapes:output, - oslc_sysml_shapes:ownedAnnotation, - oslc_sysml_shapes:ownedConjugator, - oslc_sysml_shapes:ownedDifferencing, - oslc_sysml_shapes:ownedDisjoining, - oslc_sysml_shapes:ownedElement, - oslc_sysml_shapes:ownedEndFeature, - oslc_sysml_shapes:ownedFeature, - oslc_sysml_shapes:ownedFeatureChaining, - oslc_sysml_shapes:ownedFeatureInverting, - oslc_sysml_shapes:ownedFeatureMembership, - oslc_sysml_shapes:ownedImport, - oslc_sysml_shapes:ownedIntersecting, - oslc_sysml_shapes:ownedMember, - oslc_sysml_shapes:ownedMembership, - oslc_sysml_shapes:ownedRedefinition, - oslc_sysml_shapes:ownedReferenceSubsetting, - oslc_sysml_shapes:ownedRelationship, - oslc_sysml_shapes:ownedSpecialization, - oslc_sysml_shapes:ownedSubsetting, - oslc_sysml_shapes:ownedTypeFeaturing, - oslc_sysml_shapes:ownedTyping, - oslc_sysml_shapes:ownedUnioning, - oslc_sysml_shapes:owner, - oslc_sysml_shapes:owningDefinition, - oslc_sysml_shapes:owningFeatureMembership, - oslc_sysml_shapes:owningMembership, - oslc_sysml_shapes:owningNamespace, - oslc_sysml_shapes:owningRelationship, - oslc_sysml_shapes:owningUsage, - oslc_sysml_shapes:portionKind, - oslc_sysml_shapes:qualifiedName, - oslc_sysml_shapes:refine, - oslc_sysml_shapes:satisfy, - oslc_sysml_shapes:serviceProvider, - oslc_sysml_shapes:shortName, - oslc_sysml_shapes:shortTitle, - oslc_sysml_shapes:source, - oslc_sysml_shapes:textualRepresentation, - oslc_sysml_shapes:title, - oslc_sysml_shapes:trace, - oslc_sysml_shapes:type, - oslc_sysml_shapes:untilArgument, - oslc_sysml_shapes:whileArgument ; - dcterms:description "A WhileLoopActionUsage is a LoopActionUsage that specifies that the bodyAction ActionUsage should be performed repeatedly while the result of the whileArgument Expression is true or until the result of the untilArgument Expression (if provided) is true. The whileArgument Expression is evaluated before each (possible) performance of the bodyAction, and the untilArgument Expression is evaluated after each performance of the bodyAction."^^rdf:XMLLiteral ; - dcterms:title "WhileLoopActionUsageShape"^^rdf:XMLLiteral . - -oslc_sysml_shapes:allocation a oslc:Property ; - oslc:name "allocation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:allocation ; - oslc:range oslc_sysml:AllocationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AllocationUsages that refine the allocation mapping defined by this AllocationDefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:allocationDefinition a oslc:Property ; - oslc:name "allocationDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:allocationDefinition ; - oslc:range oslc_sysml:AllocationDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AllocationDefinitions that are the types of this AllocationUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:analysisCaseDefinition a oslc:Property ; - oslc:name "analysisCaseDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:analysisCaseDefinition ; - oslc:range oslc_sysml:AnalysisCaseDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AnalysisCaseDefinition that is the definition of this AnalysisCaseUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:annotatingElement a oslc:Property ; - oslc:name "annotatingElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:annotatingElement ; - oslc:range oslc_sysml:AnnotatingElement ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AnnotatingElement that annotates the annotatedElement of this Annotation."^^rdf:XMLLiteral . - -oslc_sysml_shapes:bound a oslc:Property ; - oslc:name "bound" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:bound ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned Expressions of the MultiplicityRange whose results provide its bounds. These must be the only ownedMembers of the MultiplicityRange."^^rdf:XMLLiteral . - -oslc_sysml_shapes:client a oslc:Property ; - oslc:name "client" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:client ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element or Elements dependent on the supplier Elements."^^rdf:XMLLiteral . - -oslc_sysml_shapes:concernDefinition a oslc:Property ; - oslc:name "concernDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:concernDefinition ; - oslc:range oslc_sysml:ConcernDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernDefinition that is the single type of this ConcernUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:condition a oslc:Property ; - oslc:name "condition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:condition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The model-level evaluable Boolean-valued Expression used to filter the imported members of the membershipOwningNamespace of this ElementFilterMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:disjoiningType a oslc:Property ; - oslc:name "disjoiningType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:disjoiningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type asserted to be disjoint with the typeDisjoined."^^rdf:XMLLiteral . - -oslc_sysml_shapes:documentedElement a oslc:Property ; - oslc:name "documentedElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:documentedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element that is documented by this Documentation."^^rdf:XMLLiteral . - -oslc_sysml_shapes:effectAction a oslc:Property ; - oslc:name "effectAction" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:effectAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that define the effects of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = effect, which must all be ActionUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:elseAction a oslc:Property ; - oslc:name "elseAction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:elseAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage that is to be performed if the result of the ifArgument is false. It is the (optional) third parameter of the IfActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:enumeratedValue a oslc:Property ; - oslc:name "enumeratedValue" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:enumeratedValue ; - oslc:range oslc_sysml:EnumerationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "EnumerationUsages of this EnumerationDefinitionthat have distinct, fixed values. Each enumeratedValue specifies one of the allowed instances of the EnumerationDefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:enumerationDefinition a oslc:Property ; - oslc:name "enumerationDefinition" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:enumerationDefinition ; - oslc:range oslc_sysml:EnumerationDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The single EnumerationDefinition that is the type of this EnumerationUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:exhibitedState a oslc:Property ; - oslc:name "exhibitedState" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:exhibitedState ; - oslc:range oslc_sysml:StateUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The StateUsage to be exhibited by the ExhibitStateUsage. It is the performedAction of the ExhibitStateUsage considered as a PerformActionUsage, which must be a StateUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:exposedElement a oslc:Property ; - oslc:name "exposedElement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:exposedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are exposed by this ViewUsage, which are those memberElements of the imported Memberships from all the Expose Relationships that meet all the owned and inherited viewConditions."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureChained a oslc:Property ; - oslc:name "featureChained" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featureChained ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature whose values are partly determined by values of the chainingFeature, as described in Feature::chainingFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureInverted a oslc:Property ; - oslc:name "featureInverted" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featureInverted ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is an inverse of the invertingFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureOfType a oslc:Property ; - oslc:name "featureOfType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featureOfType ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is featured by the featuringType. It is the source of the TypeFeaturing."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureWithValue a oslc:Property ; - oslc:name "featureWithValue" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featureWithValue ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature to be provided a value."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ifArgument a oslc:Property ; - oslc:name "ifArgument" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ifArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result determines whether the thenAction or (optionally) the elseAction is performed. It is the first parameter of the IfActionUsage.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:interfaceDefinition a oslc:Property ; - oslc:name "interfaceDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:interfaceDefinition ; - oslc:range oslc_sysml:InterfaceDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The InterfaceDefinitions that type this InterfaceUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:interfaceEnd a oslc:Property ; - oslc:name "interfaceEnd" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:interfaceEnd ; - oslc:range oslc_sysml:PortUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description """The PortUsages that are the connectionEnds of this InterfaceDefinition. - -."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:invertingFeature a oslc:Property ; - oslc:name "invertingFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:invertingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is an inverse of the invertedFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isDefault a oslc:Property ; - oslc:name "isDefault" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isDefault ; - oslc:readOnly false ; - dcterms:description "Whether this FeatureValue is a concrete specification of the bound or initial value of the featureWithValue, or just a default value that may be overridden."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isInitial a oslc:Property ; - oslc:name "isInitial" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isInitial ; - oslc:readOnly false ; - dcterms:description "Whether this FeatureValue specifies a bound value or an initial value for the featureWithValue."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isStandard a oslc:Property ; - oslc:name "isStandard" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isStandard ; - oslc:readOnly false ; - dcterms:description "Whether this LibraryPackage contains a standard library model. This should only be set to true for LibraryPackages in the standard Kernel Model Libraries or in normative model libraries for a language built on KerML."^^rdf:XMLLiteral . - -oslc_sysml_shapes:language a oslc:Property ; - oslc:name "language" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:language ; - oslc:readOnly false ; - dcterms:description "The natural or artifical language in which the body text is written."^^rdf:XMLLiteral . - -oslc_sysml_shapes:loopVariable a oslc:Property ; - oslc:name "loopVariable" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:loopVariable ; - oslc:range oslc_sysml:ReferenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedFeature of this ForLoopActionUsage that acts as the loop variable, which is assigned the successive values of the input sequence on each iteration. It is the ownedFeature that redefines ForLoopAction::var.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:lowerBound a oslc:Property ; - oslc:name "lowerBound" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:lowerBound ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result provides the lower bound of the MultiplicityRange. If no lowerBound Expression is given, then the lower bound shall have the same value as the upper bound, unless the upper bound is unbounded (*), in which case the lower bound shall be 0."^^rdf:XMLLiteral . - -oslc_sysml_shapes:metadataDefinition a oslc:Property ; - oslc:name "metadataDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:metadataDefinition ; - oslc:range oslc_sysml:Metaclass ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The MetadataDefinition that is the definition of this MetadataUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedActorParameter a oslc:Property ; - oslc:name "ownedActorParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedActorParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsage specifying the actor."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedObjectiveRequirement a oslc:Property ; - oslc:name "ownedObjectiveRequirement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedObjectiveRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage that is the ownedMemberFeature of this RequirementUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedPortConjugator a oslc:Property ; - oslc:name "ownedPortConjugator" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedPortConjugator ; - oslc:range oslc_sysml:PortConjugation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PortConjugation that is the ownedConjugator of this ConjugatedPortDefinition, linking it to its originalPortDefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedResultExpression a oslc:Property ; - oslc:name "ownedResultExpression" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedResultExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression that provides the result for the owner of the ResultExpressionMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedStakeholderParameter a oslc:Property ; - oslc:name "ownedStakeholderParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedStakeholderParameter ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsage specifying the stakeholder."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedSubjectParameter a oslc:Property ; - oslc:name "ownedSubjectParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedSubjectParameter ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UsageownedMemberParameter of this SubjectMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedVariantUsage a oslc:Property ; - oslc:name "ownedVariantUsage" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedVariantUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usage that represents a variant in the context of the owningVariationDefinition or owningVariationUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningAnnotatedElement a oslc:Property ; - oslc:name "owningAnnotatedElement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningAnnotatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The annotatedElement of this Annotation, when it is also its owningRelatedElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningAnnotatingElement a oslc:Property ; - oslc:name "owningAnnotatingElement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningAnnotatingElement ; - oslc:range oslc_sysml:AnnotatingElement ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The annotatingElement of this Annotation, when it is also its owningRelatedElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningClassifier a oslc:Property ; - oslc:name "owningClassifier" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningClassifier ; - oslc:range oslc_sysml:Classifier ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Classifier that owns this Subclassification relationship, which must also be its subclassifier."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningFeatureOfType a oslc:Property ; - oslc:name "owningFeatureOfType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeatureOfType ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A featureOfType that is also the owningRelatedElement of this TypeFeaturing."^^rdf:XMLLiteral . - -oslc_sysml_shapes:payloadParameter a oslc:Property ; - oslc:name "payloadParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:payloadParameter ; - oslc:range oslc_sysml:ReferenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The nestedReference of this AcceptActionUsage that redefines the payload output parameter of the base AcceptActionUsage AcceptAction from the Systems Model Library."^^rdf:XMLLiteral . - -oslc_sysml_shapes:redefinedFeature a oslc:Property ; - oslc:name "redefinedFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:redefinedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is redefined by the redefiningFeature of this Redefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:redefiningFeature a oslc:Property ; - oslc:name "redefiningFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:redefiningFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is redefining the redefinedFeature of this Redefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencedConcern a oslc:Property ; - oslc:name "referencedConcern" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description " The ConcernUsage that is referenced through this FramedConcernMembership. It is the referencedConstraint of the FramedConcernMembership considered as a RequirementConstraintMembership, which must be a ConcernUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencedElement a oslc:Property ; - oslc:name "referencedElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description " The Element whose metadata is being accessed."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencedFeature a oslc:Property ; - oslc:name "referencedFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is referenced by the referencingFeature of this ReferenceSubsetting."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencedRendering a oslc:Property ; - oslc:name "referencedRendering" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description " The RenderingUsage that is referenced through this ViewRenderingMembership. It is the referencedFeature of the ownedReferenceSubsetting for the ownedRendering, if there is one, and, otherwise, the ownedRendering itself."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencingFeature a oslc:Property ; - oslc:name "referencingFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that owns this ReferenceSubsetting relationship, which is also its subsettingFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:rendering a oslc:Property ; - oslc:name "rendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:rendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of a RenderingDefinition that are RenderingUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:renderingDefinition a oslc:Property ; - oslc:name "renderingDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:renderingDefinition ; - oslc:range oslc_sysml:RenderingDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingDefinition that is the definition of this RenderingUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:representedElement a oslc:Property ; - oslc:name "representedElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:representedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element that is represented by this TextualRepresentation."^^rdf:XMLLiteral . - -oslc_sysml_shapes:satisfiedRequirement a oslc:Property ; - oslc:name "satisfiedRequirement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:satisfiedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsage that is satisfied by the satisfyingSubject of this SatisfyRequirementUsage. It is the assertedConstraint of the SatisfyRequirementUsage considered as an AssertConstraintUsage, which must be a RequirementUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:satisfyingFeature a oslc:Property ; - oslc:name "satisfyingFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:satisfyingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that represents the actual subject that is asserted to satisfy the satisfiedRequirement. The satisfyingFeature is bound to the subjectParameter of the SatisfyRequirementUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:senderArgument a oslc:Property ; - oslc:name "senderArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:senderArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An Expression whose result is bound to the sender input parameter of this SendActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:seqArgument a oslc:Property ; - oslc:name "seqArgument" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:seqArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result provides the sequence of values to which the loopVariable is set for each iterative performance of the bodyAction. It is the Expression whose result is bound to the seq input parameter of this ForLoopActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:state a oslc:Property ; - oslc:name "state" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:state ; - oslc:range oslc_sysml:StateUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The StateUsages, which are actions in the StateDefinition, that specify the discrete states in the behavior defined by the StateDefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:subclassifier a oslc:Property ; - oslc:name "subclassifier" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subclassifier ; - oslc:range oslc_sysml:Classifier ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The more specific Classifier in this Subclassification."^^rdf:XMLLiteral . - -oslc_sysml_shapes:succession a oslc:Property ; - oslc:name "succession" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:succession ; - oslc:range oslc_sysml:Succession ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Succession that is the ownedFeature of this TransitionUsage, which, if the TransitionUsage is triggered, asserts the temporal ordering of the source and target."^^rdf:XMLLiteral . - -oslc_sysml_shapes:superclassifier a oslc:Property ; - oslc:name "superclassifier" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:superclassifier ; - oslc:range oslc_sysml:Classifier ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The more general Classifier in this Subclassification."^^rdf:XMLLiteral . - -oslc_sysml_shapes:supplier a oslc:Property ; - oslc:name "supplier" ; - oslc:occurs oslc:One-or-many ; - oslc:propertyDefinition oslc_sysml:supplier ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element or Elements on which the client Elements depend in some respect."^^rdf:XMLLiteral . - -oslc_sysml_shapes:targetArgument a oslc:Property ; - oslc:name "targetArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:targetArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose value is an occurrence in the domain of the referent Feature, for which the value of the referent will be set to the result of the valueExpression by this AssignmentActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:terminatedOccurrenceArgument a oslc:Property ; - oslc:name "terminatedOccurrenceArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:terminatedOccurrenceArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression that is the featureValue of the terminateOccurrence parameter of this TerminateActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:thenAction a oslc:Property ; - oslc:name "thenAction" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:thenAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage that is to be performed if the result of the ifArgument is true. It is the second parameter of the IfActionUsage.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:transitionFeature a oslc:Property ; - oslc:name "transitionFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:transitionFeature ; - oslc:range oslc_sysml:Step ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Step that is the ownedMemberFeature of this TransitionFeatureMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:triggerAction a oslc:Property ; - oslc:name "triggerAction" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:triggerAction ; - oslc:range oslc_sysml:AcceptActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AcceptActionUsages that define the triggers of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = trigger, which must all be AcceptActionUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:typeDifferenced a oslc:Property ; - oslc:name "typeDifferenced" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:typeDifferenced ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type with interpretations partly determined by differencingType, as described in Type::differencingType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:typeDisjoined a oslc:Property ; - oslc:name "typeDisjoined" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:typeDisjoined ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type asserted to be disjoint with the disjoiningType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:typeIntersected a oslc:Property ; - oslc:name "typeIntersected" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:typeIntersected ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type with interpretations partly determined by intersectingType, as described in Type::intersectingType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:typeUnioned a oslc:Property ; - oslc:name "typeUnioned" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:typeUnioned ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Type with interpretations partly determined by unioningType, as described in Type::unioningType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:untilArgument a oslc:Property ; - oslc:name "untilArgument" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:untilArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result, if false, determines that the bodyAction should continue to be performed. It is the (optional) third owned parameter of the WhileLoopActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:upperBound a oslc:Property ; - oslc:name "upperBound" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:upperBound ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result is the upper bound of the MultiplicityRange."^^rdf:XMLLiteral . - -oslc_sysml_shapes:useCaseIncluded a oslc:Property ; - oslc:name "useCaseIncluded" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:useCaseIncluded ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsage to be included by this IncludeUseCaseUsage. It is the performedAction of the IncludeUseCaseUsage considered as a PerformActionUsage, which must be a UseCaseUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:valueExpression a oslc:Property ; - oslc:name "valueExpression" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:valueExpression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result is to be assigned to the referent Feature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:verificationCaseDefinition a oslc:Property ; - oslc:name "verificationCaseDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:verificationCaseDefinition ; - oslc:range oslc_sysml:VerificationCaseDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The VerificationCase that is the definition of this VerificationCaseUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:view a oslc:Property ; - oslc:name "view" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:view ; - oslc:range oslc_sysml:ViewUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The usages of this ViewDefinition that are ViewUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:viewDefinition a oslc:Property ; - oslc:name "viewDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewDefinition ; - oslc:range oslc_sysml:ViewDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewDefinition that is the definition of this ViewUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:viewpointDefinition a oslc:Property ; - oslc:name "viewpointDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:viewpointDefinition ; - oslc:range oslc_sysml:ViewpointDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewpointDefinition that is the definition of this ViewpointUsage.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:whileArgument a oslc:Property ; - oslc:name "whileArgument" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:whileArgument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expression whose result, if true, determines that the bodyAction should continue to be performed. It is the first owned parameter of the WhileLoopActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:assertedConstraint a oslc:Property ; - oslc:name "assertedConstraint" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:assertedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsage to be performed by the AssertConstraintUsage. It is the referenceFeature of the ownedReferenceSubsetting for the AssertConstraintUsage, if there is one, and, otherwise, the AssertConstraintUsage itself."^^rdf:XMLLiteral . - -oslc_sysml_shapes:attributeDefinition a oslc:Property ; - oslc:name "attributeDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:attributeDefinition ; - oslc:range oslc_sysml:DataType ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The DataTypes that are the types of this AttributeUsage. Nominally, these are AttributeDefinitions, but other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:conjugatedType a oslc:Property ; - oslc:name "conjugatedType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:conjugatedType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is the result of applying Conjugation to the originalType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:filterCondition a oslc:Property ; - oslc:name "filterCondition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:filterCondition ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The model-level evaluable Boolean-valued Expression used to filter the members of this Package, which are owned by the Package are via ElementFilterMemberships."^^rdf:XMLLiteral . - -oslc_sysml_shapes:flowConnectionDefinition a oslc:Property ; - oslc:name "flowConnectionDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:flowConnectionDefinition ; - oslc:range oslc_sysml:Interaction ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Interactions that are the types of this FlowConnectionUsage. Nominally, these are FlowConnectionDefinitions, but other kinds of Kernel Interactions are also allowed, to permit use of Interactions from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:importedNamespace a oslc:Property ; - oslc:name "importedNamespace" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:importedNamespace ; - oslc:range oslc_sysml:Namespace ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Namespace whose visible Memberships are imported by this NamespaceImport."^^rdf:XMLLiteral . - -oslc_sysml_shapes:locale a oslc:Property ; - oslc:name "locale" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:locale ; - oslc:readOnly false ; - dcterms:description "Identification of the language of the body text and, optionally, the region and/or encoding. The format shall be a POSIX locale conformant to ISO/IEC 15897, with the format [language[_territory][.codeset][@modifier]]."^^rdf:XMLLiteral . - -oslc_sysml_shapes:metaclass a oslc:Property ; - oslc:name "metaclass" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:metaclass ; - oslc:range oslc_sysml:Metaclass ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The type of this MetadataFeature, which must be a Metaclass."^^rdf:XMLLiteral . - -oslc_sysml_shapes:originalType a oslc:Property ; - oslc:name "originalType" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:originalType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type to be conjugated."^^rdf:XMLLiteral . - -oslc_sysml_shapes:stateDefinition a oslc:Property ; - oslc:name "stateDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:stateDefinition ; - oslc:range oslc_sysml:Behavior ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Behaviors that are the types of this StateUsage. Nominally, these would be StateDefinitions, but kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:typedFeature a oslc:Property ; - oslc:name "typedFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:typedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that has a type determined by this FeatureTyping."^^rdf:XMLLiteral . - -oslc_sysml_shapes:useCaseDefinition a oslc:Property ; - oslc:name "useCaseDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:useCaseDefinition ; - oslc:range oslc_sysml:UseCaseDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseDefinition that is the definition of this UseCaseUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:bodyAction a oslc:Property ; - oslc:name "bodyAction" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:bodyAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage to be performed repeatedly by the LoopActionUsage. It is the second parameter of the LoopActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isNegated a oslc:Property ; - oslc:name "isNegated" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isNegated ; - oslc:readOnly false ; - dcterms:description "Whether this Invariant is asserted to be false rather than true."^^rdf:XMLLiteral . - -oslc_sysml_shapes:performedAction a oslc:Property ; - oslc:name "performedAction" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:performedAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsage to be performed by this PerformedActionUsage. It is the eventOccurrence of the PerformActionUsage considered as an EventOccurrenceUsage, which must be an ActionUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:referencedConstraint a oslc:Property ; - oslc:name "referencedConstraint" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:referencedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description " The ConstraintUsage that is referenced through this RequirementConstraintMembership. It is the referencedFeature of the ownedReferenceSubsetting of the ownedConstraint, if there is one, and, otherwise, the ownedConstraint itself."^^rdf:XMLLiteral . - -oslc_sysml_shapes:subsettedFeature a oslc:Property ; - oslc:name "subsettedFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subsettedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is subsetted by the subsettingFeature of this Subsetting."^^rdf:XMLLiteral . - -oslc_sysml_shapes:subsettingFeature a oslc:Property ; - oslc:name "subsettingFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:subsettingFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is a subset of the subsettedFeature of this Subsetting."^^rdf:XMLLiteral . - -oslc_sysml_shapes:connectionEnd a oslc:Property ; - oslc:name "connectionEnd" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:connectionEnd ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that define the things related by the ConnectionDefinition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:effectStep a oslc:Property ; - oslc:name "effectStep" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:effectStep ; - oslc:range oslc_sysml:Step ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Steps that represent occurrences that are side effects of the transitionStep occurring."^^rdf:XMLLiteral . - -oslc_sysml_shapes:eventOccurrence a oslc:Property ; - oslc:name "eventOccurrence" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:eventOccurrence ; - oslc:range oslc_sysml:OccurrenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The OccurrenceUsage referenced as an event by this EventOccurrenceUsage. It is the referenceFeature of the ownedReferenceSubsetting for the EventOccurrenceUsage, if there is one, and, otherwise, the EventOccurrenceUsage itself."^^rdf:XMLLiteral . - -oslc_sysml_shapes:interaction a oslc:Property ; - oslc:name "interaction" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:interaction ; - oslc:range oslc_sysml:Interaction ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Interactions that type this ItemFlow. Interactions are both Associations and Behaviors, which can type Connectors and Steps, respectively."^^rdf:XMLLiteral . - -oslc_sysml_shapes:itemFeature a oslc:Property ; - oslc:name "itemFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:itemFeature ; - oslc:range oslc_sysml:ItemFeature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedFeature of the ItemFlow that is an ItemFeature (if any)."^^rdf:XMLLiteral . - -oslc_sysml_shapes:itemFlowEnd a oslc:Property ; - oslc:name "itemFlowEnd" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:itemFlowEnd ; - oslc:range oslc_sysml:ItemFlowEnd ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The connectorEnds of this ItemFlow that are ItemFlowEnds."^^rdf:XMLLiteral . - -oslc_sysml_shapes:itemType a oslc:Property ; - oslc:name "itemType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:itemType ; - oslc:range oslc_sysml:Classifier ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The type of values transferred, which is the type of the itemFeature of the ItemFlow."^^rdf:XMLLiteral . - -oslc_sysml_shapes:operator a oslc:Property ; - oslc:name "operator" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:operator ; - oslc:readOnly false ; - dcterms:description "An operator symbol that names a corresponding Function from one of the standard packages from the Kernel Function Library ."^^rdf:XMLLiteral . - -oslc_sysml_shapes:requirementDefinition a oslc:Property ; - oslc:name "requirementDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:requirementDefinition ; - oslc:range oslc_sysml:RequirementDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementDefinition that is the single definition of this RequirementUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:sourceOutputFeature a oslc:Property ; - oslc:name "sourceOutputFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:sourceOutputFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that provides the items carried by the ItemFlow. It must be an owned output of the source of the ItemFlow."^^rdf:XMLLiteral . - -oslc_sysml_shapes:targetInputFeature a oslc:Property ; - oslc:name "targetInputFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:targetInputFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that receives the values carried by the ItemFlow. It must be an owned output of the target participant of the ItemFlow."^^rdf:XMLLiteral . - -oslc_sysml_shapes:transitionStep a oslc:Property ; - oslc:name "transitionStep" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:transitionStep ; - oslc:range oslc_sysml:Step ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A Step that is typed by the Behavior TransitionPerformances::TransitionPerformance (from the Kernel Semantic Library) that has this Succession as its transitionLink."^^rdf:XMLLiteral . - -oslc_sysml_shapes:triggerStep a oslc:Property ; - oslc:name "triggerStep" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:triggerStep ; - oslc:range oslc_sysml:Step ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "Steps that map incoming events to the timing of occurrences of the transitionStep. The values of triggerStep subset the list of acceptable events to be received by a Behavior or the object that performs it."^^rdf:XMLLiteral . - -oslc_sysml_shapes:calculation a oslc:Property ; - oslc:name "calculation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:calculation ; - oslc:range oslc_sysml:CalculationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The actions of this CalculationDefinition that are CalculationUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:caseDefinition a oslc:Property ; - oslc:name "caseDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:caseDefinition ; - oslc:range oslc_sysml:CaseDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The CaseDefinition that is the type of this CaseUsage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:connectionDefinition a oslc:Property ; - oslc:name "connectionDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:connectionDefinition ; - oslc:range oslc_sysml:AssociationStructure ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AssociationStructures that are the types of this ConnectionUsage. Nominally, these are , but other kinds of Kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberParameter a oslc:Property ; - oslc:name "ownedMemberParameter" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberParameter ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that is identified as a parameter by this ParameterMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:annotation a oslc:Property ; - oslc:name "annotation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:annotation ; - oslc:range oslc_sysml:Annotation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Annotations that relate this AnnotatingElement to its annotatedElements."^^rdf:XMLLiteral . - -oslc_sysml_shapes:argument a oslc:Property ; - oslc:name "argument" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:argument ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The value Expressions of the FeatureValues of the owned input parameters of the InvocationExpression."^^rdf:XMLLiteral . - -oslc_sysml_shapes:calculationDefinition a oslc:Property ; - oslc:name "calculationDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:calculationDefinition ; - oslc:range oslc_sysml:Function ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Function that is the type of this CalculationUsage. Nominally, this would be a CalculationDefinition, but a kernel Function is also allowed, to permit use of Functions from the Kernel Model Libraries.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:constraintDefinition a oslc:Property ; - oslc:name "constraintDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:constraintDefinition ; - oslc:range oslc_sysml:Predicate ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The (single) Predicate that is the type of this ConstraintUsage. Nominally, this will be a ConstraintDefinition, but other kinds of Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:importOwningNamespace a oslc:Property ; - oslc:name "importOwningNamespace" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:importOwningNamespace ; - oslc:range oslc_sysml:Namespace ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Namespace into which Memberships are imported by this Import, which must be the owningRelatedElement of the Import."^^rdf:XMLLiteral . - -oslc_sysml_shapes:importedElement a oslc:Property ; - oslc:name "importedElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:importedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The effectively imported Element for this Import. For a MembershipImport, this is the memberElement of the importedMembership. For a NamespaceImport, it is the importedNamespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isImportAll a oslc:Property ; - oslc:name "isImportAll" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isImportAll ; - oslc:readOnly false ; - dcterms:description "Whether to import memberships without regard to declared visibility."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isRecursive a oslc:Property ; - oslc:name "isRecursive" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isRecursive ; - oslc:readOnly false ; - dcterms:description "Whether to recursively import Memberships from visible, owned sub-Namespaces."^^rdf:XMLLiteral . - -oslc_sysml_shapes:operand a oslc:Property ; - oslc:name "operand" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:operand ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "operand."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAnnotatingRelationship a oslc:Property ; - oslc:name "ownedAnnotatingRelationship" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAnnotatingRelationship ; - oslc:range oslc_sysml:Annotation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this AnnotatingElement that are Annotations, for which this AnnotatingElement is the annotatingElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:associationEnd a oslc:Property ; - oslc:name "associationEnd" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:associationEnd ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The features of the Association that identify the things that can be related by it. A concrete Association must have at least two associationEnds. When it has exactly two, the Association is called a binary Association."^^rdf:XMLLiteral . - -oslc_sysml_shapes:general a oslc:Property ; - oslc:name "general" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:general ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A Type with a superset of all instances of the specific Type, which might be the same set."^^rdf:XMLLiteral . - -oslc_sysml_shapes:relatedType a oslc:Property ; - oslc:name "relatedType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:relatedType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The types of the associationEnds of the Association, which are the relatedElements of the Association considered as a Relationship."^^rdf:XMLLiteral . - -oslc_sysml_shapes:sourceType a oslc:Property ; - oslc:name "sourceType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:sourceType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The source relatedType for this Association. It is the first relatedType of the Association."^^rdf:XMLLiteral . - -oslc_sysml_shapes:specific a oslc:Property ; - oslc:name "specific" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:specific ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A Type with a subset of all instances of the general Type, which might be the same set."^^rdf:XMLLiteral . - -oslc_sysml_shapes:targetType a oslc:Property ; - oslc:name "targetType" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:targetType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The target relatedTypes for this Association. This includes all the relatedTypes other than the sourceType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:partDefinition a oslc:Property ; - oslc:name "partDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:partDefinition ; - oslc:range oslc_sysml:PartDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The itemDefinitions of this PartUsage that are PartDefinitions."^^rdf:XMLLiteral . - -oslc_sysml_shapes:predicate a oslc:Property ; - oslc:name "predicate" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:predicate ; - oslc:range oslc_sysml:Predicate ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Predicate that types this BooleanExpression."^^rdf:XMLLiteral . - -oslc_sysml_shapes:itemDefinition a oslc:Property ; - oslc:name "itemDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:itemDefinition ; - oslc:range oslc_sysml:Structure ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Structures that are the definitions of this ItemUsage. Nominally, these are ItemDefinitions, but other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Library."^^rdf:XMLLiteral . - -oslc_sysml_shapes:expression a oslc:Property ; - oslc:name "expression" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:expression ; - oslc:range oslc_sysml:Expression ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Expressions that are steps in the calculation of the result of this Function."^^rdf:XMLLiteral . - -oslc_sysml_shapes:association a oslc:Property ; - oslc:name "association" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:association ; - oslc:range oslc_sysml:Association ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Associations that type the Connector."^^rdf:XMLLiteral . - -oslc_sysml_shapes:connectorEnd a oslc:Property ; - oslc:name "connectorEnd" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:connectorEnd ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The endFeatures of a Connector, which redefine the endFeatures of the associations of the Connector. The connectorEnds determine via ReferenceSubsetting Relationships which Features are related by the Connector."^^rdf:XMLLiteral . - -oslc_sysml_shapes:relatedFeature a oslc:Property ; - oslc:name "relatedFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:relatedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Features that are related by this Connector considered as a Relationship and that restrict the links it identifies, given by the referenced Features of the connectorEnds of the Connector."^^rdf:XMLLiteral . - -oslc_sysml_shapes:sourceFeature a oslc:Property ; - oslc:name "sourceFeature" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:sourceFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The source relatedFeature for this Connector. It is the first relatedFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberFeature a oslc:Property ; - oslc:name "ownedMemberFeature" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Feature that this FeatureMembership relates to its owningType, making it an ownedFeature of the owningType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:step a oslc:Property ; - oslc:name "step" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:step ; - oslc:range oslc_sysml:Step ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Steps that make up this Behavior."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberElement a oslc:Property ; - oslc:name "ownedMemberElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element that becomes an ownedMember of the membershipOwningNamespace due to this OwningMembership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberElementId a oslc:Property ; - oslc:name "ownedMemberElementId" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberElementId ; - oslc:readOnly false ; - dcterms:description "The elementId of the ownedMemberElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberName a oslc:Property ; - oslc:name "ownedMemberName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberName ; - oslc:readOnly false ; - dcterms:description "The name of the ownedMemberElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMemberShortName a oslc:Property ; - oslc:name "ownedMemberShortName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:ownedMemberShortName ; - oslc:readOnly false ; - dcterms:description "The shortName of the ownedMemberElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:memberElement a oslc:Property ; - oslc:name "memberElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:memberElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Element that becomes a member of the membershipOwningNamespace due to this Membership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:memberElementId a oslc:Property ; - oslc:name "memberElementId" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:memberElementId ; - oslc:readOnly false ; - dcterms:description "The elementId of the memberElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:memberName a oslc:Property ; - oslc:name "memberName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:memberName ; - oslc:readOnly false ; - dcterms:description "The name of the memberElement relative to the membershipOwningNamespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:memberShortName a oslc:Property ; - oslc:name "memberShortName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:memberShortName ; - oslc:readOnly false ; - dcterms:description "The short name of the memberElement relative to the membershipOwningNamespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:membershipOwningNamespace a oslc:Property ; - oslc:name "membershipOwningNamespace" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:membershipOwningNamespace ; - oslc:range oslc_sysml:Namespace ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Namespace of which the memberElement becomes a member due to this Membership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:lifeClass a oslc:Property ; - oslc:name "lifeClass" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:lifeClass ; - oslc:range oslc_sysml:LifeClass ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "If isIndividual is true, a LifeClass that specializes this OccurrenceDefinition, restricting it to represent an individual."^^rdf:XMLLiteral . - -oslc_sysml_shapes:actionDefinition a oslc:Property ; - oslc:name "actionDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:actionDefinition ; - oslc:range oslc_sysml:Behavior ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Behaviors that are the types of this ActionUsage. Nominally, these would be ActionDefinitions, but other kinds of Kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAction a oslc:Property ; - oslc:name "ownedAction" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAllocation a oslc:Property ; - oslc:name "ownedAllocation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAllocation ; - oslc:range oslc_sysml:AllocationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AllocationUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAnalysisCase a oslc:Property ; - oslc:name "ownedAnalysisCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAnalysisCase ; - oslc:range oslc_sysml:AnalysisCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AnalysisCaseUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAttribute a oslc:Property ; - oslc:name "ownedAttribute" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAttribute ; - oslc:range oslc_sysml:AttributeUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AttributeUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedCalculation a oslc:Property ; - oslc:name "ownedCalculation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedCalculation ; - oslc:range oslc_sysml:CalculationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The CalculationUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedCase a oslc:Property ; - oslc:name "ownedCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedCase ; - oslc:range oslc_sysml:CaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The code>CaseUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedConnection a oslc:Property ; - oslc:name "ownedConnection" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedConnection ; - oslc:range oslc_sysml:ConnectorAsUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConnectorAsUsages that are ownedUsages of this Definition. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedEnumeration a oslc:Property ; - oslc:name "ownedEnumeration" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedEnumeration ; - oslc:range oslc_sysml:EnumerationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The EnumerationUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedFlow a oslc:Property ; - oslc:name "ownedFlow" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedFlow ; - oslc:range oslc_sysml:FlowConnectionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The FlowConnectionUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedInterface a oslc:Property ; - oslc:name "ownedInterface" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedInterface ; - oslc:range oslc_sysml:InterfaceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The InterfaceUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedItem a oslc:Property ; - oslc:name "ownedItem" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedItem ; - oslc:range oslc_sysml:ItemUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ItemUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMetadata a oslc:Property ; - oslc:name "ownedMetadata" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedMetadata ; - oslc:range oslc_sysml:MetadataUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The MetadataUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedOccurrence a oslc:Property ; - oslc:name "ownedOccurrence" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedOccurrence ; - oslc:range oslc_sysml:OccurrenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The OccurrenceUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedPart a oslc:Property ; - oslc:name "ownedPart" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedPart ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedPort a oslc:Property ; - oslc:name "ownedPort" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedPort ; - oslc:range oslc_sysml:PortUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PortUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedReference a oslc:Property ; - oslc:name "ownedReference" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedReference ; - oslc:range oslc_sysml:ReferenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ReferenceUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedState a oslc:Property ; - oslc:name "ownedState" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedState ; - oslc:range oslc_sysml:StateUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The StateUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedTransition a oslc:Property ; - oslc:name "ownedTransition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedTransition ; - oslc:range oslc_sysml:TransitionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The TransitionUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedUsage a oslc:Property ; - oslc:name "ownedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are ownedFeatures of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedUseCase a oslc:Property ; - oslc:name "ownedUseCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedVerificationCase a oslc:Property ; - oslc:name "ownedVerificationCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedVerificationCase ; - oslc:range oslc_sysml:VerificationCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The VerificationCaseUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedView a oslc:Property ; - oslc:name "ownedView" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedView ; - oslc:range oslc_sysml:ViewUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedViewpoint a oslc:Property ; - oslc:name "ownedViewpoint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewpointUsages that are ownedUsages of this Definition."^^rdf:XMLLiteral . - -oslc_sysml_shapes:function a oslc:Property ; - oslc:name "function" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:function ; - oslc:range oslc_sysml:Function ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Function that types this Expression."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedSubclassification a oslc:Property ; - oslc:name "ownedSubclassification" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedSubclassification ; - oslc:range oslc_sysml:Subclassification ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedSpecializations of this Classifier that are Subclassifications, for which this Classifier is the subclassifier."^^rdf:XMLLiteral . - -oslc_sysml_shapes:individualDefinition a oslc:Property ; - oslc:name "individualDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:individualDefinition ; - oslc:range oslc_sysml:OccurrenceDefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The at most one occurrenceDefinition that has isIndividual = true."^^rdf:XMLLiteral . - -oslc_sysml_shapes:occurrenceDefinition a oslc:Property ; - oslc:name "occurrenceDefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:occurrenceDefinition ; - oslc:range oslc_sysml:Class ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Classes that are the types of this OccurrenceUsage. Nominally, these are OccurrenceDefinitions, but other kinds of kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:portionKind a oslc:Property ; - oslc:name "portionKind" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:portionKind ; - oslc:readOnly false ; - dcterms:description "The kind of (temporal) portion of the life of the occurrenceDefinition represented by this OccurrenceUsage, if it is so restricted."^^rdf:XMLLiteral . - -oslc_sysml_shapes:definition a oslc:Property ; - oslc:name "definition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:definition ; - oslc:range oslc_sysml:Classifier ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Classifiers that are the types of this Usage. Nominally, these are Definitions, but other kinds of Kernel Classifiers are also allowed, to permit use of Classifiers from the Kernel Model Libraries."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isReference a oslc:Property ; - oslc:name "isReference" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isReference ; - oslc:readOnly false ; - dcterms:description "Whether this Usage is a referential Usage, that is, it has isComposite = false."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedAction a oslc:Property ; - oslc:name "nestedAction" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedAction ; - oslc:range oslc_sysml:ActionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ActionUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedAllocation a oslc:Property ; - oslc:name "nestedAllocation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedAllocation ; - oslc:range oslc_sysml:AllocationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AllocationUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedAnalysisCase a oslc:Property ; - oslc:name "nestedAnalysisCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedAnalysisCase ; - oslc:range oslc_sysml:AnalysisCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The AnalysisCaseUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedAttribute a oslc:Property ; - oslc:name "nestedAttribute" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedAttribute ; - oslc:range oslc_sysml:AttributeUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The code>AttributeUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedCalculation a oslc:Property ; - oslc:name "nestedCalculation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedCalculation ; - oslc:range oslc_sysml:CalculationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The CalculationUsage that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedCase a oslc:Property ; - oslc:name "nestedCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedCase ; - oslc:range oslc_sysml:CaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The CaseUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedConcern a oslc:Property ; - oslc:name "nestedConcern" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedConcern ; - oslc:range oslc_sysml:ConcernUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConcernUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedConnection a oslc:Property ; - oslc:name "nestedConnection" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedConnection ; - oslc:range oslc_sysml:ConnectorAsUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConnectorAsUsages that are nestedUsages of this Usage. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedConstraint a oslc:Property ; - oslc:name "nestedConstraint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedConstraint ; - oslc:range oslc_sysml:ConstraintUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ConstraintUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedEnumeration a oslc:Property ; - oslc:name "nestedEnumeration" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedEnumeration ; - oslc:range oslc_sysml:EnumerationUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The code>EnumerationUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedFlow a oslc:Property ; - oslc:name "nestedFlow" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedFlow ; - oslc:range oslc_sysml:FlowConnectionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The code>FlowConnectionUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedInterface a oslc:Property ; - oslc:name "nestedInterface" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedInterface ; - oslc:range oslc_sysml:InterfaceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The InterfaceUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedItem a oslc:Property ; - oslc:name "nestedItem" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedItem ; - oslc:range oslc_sysml:ItemUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ItemUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedMetadata a oslc:Property ; - oslc:name "nestedMetadata" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedMetadata ; - oslc:range oslc_sysml:MetadataUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The MetadataUsages that are nestedUsages of this of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedOccurrence a oslc:Property ; - oslc:name "nestedOccurrence" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedOccurrence ; - oslc:range oslc_sysml:OccurrenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The OccurrenceUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedPart a oslc:Property ; - oslc:name "nestedPart" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedPart ; - oslc:range oslc_sysml:PartUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PartUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedPort a oslc:Property ; - oslc:name "nestedPort" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedPort ; - oslc:range oslc_sysml:PortUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The PortUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedReference a oslc:Property ; - oslc:name "nestedReference" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedReference ; - oslc:range oslc_sysml:ReferenceUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ReferenceUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedRendering a oslc:Property ; - oslc:name "nestedRendering" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedRendering ; - oslc:range oslc_sysml:RenderingUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RenderingUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedRequirement a oslc:Property ; - oslc:name "nestedRequirement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedRequirement ; - oslc:range oslc_sysml:RequirementUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The RequirementUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedState a oslc:Property ; - oslc:name "nestedState" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedState ; - oslc:range oslc_sysml:StateUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The StateUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedTransition a oslc:Property ; - oslc:name "nestedTransition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedTransition ; - oslc:range oslc_sysml:TransitionUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The TransitionUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedUsage a oslc:Property ; - oslc:name "nestedUsage" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usages that are ownedFeatures of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedUseCase a oslc:Property ; - oslc:name "nestedUseCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedUseCase ; - oslc:range oslc_sysml:UseCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The UseCaseUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedVerificationCase a oslc:Property ; - oslc:name "nestedVerificationCase" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedVerificationCase ; - oslc:range oslc_sysml:VerificationCaseUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The VerificationCaseUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedView a oslc:Property ; - oslc:name "nestedView" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedView ; - oslc:range oslc_sysml:ViewUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:nestedViewpoint a oslc:Property ; - oslc:name "nestedViewpoint" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:nestedViewpoint ; - oslc:range oslc_sysml:ViewpointUsage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ViewpointUsages that are nestedUsages of this Usage."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningDefinition a oslc:Property ; - oslc:name "owningDefinition" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningDefinition ; - oslc:range oslc_sysml:Definition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Definition that owns this Usage (if any)."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningUsage a oslc:Property ; - oslc:name "owningUsage" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningUsage ; - oslc:range oslc_sysml:Usage ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Usage in which this Usage is nested (if any)."^^rdf:XMLLiteral . - -oslc_sysml_shapes:behavior a oslc:Property ; - oslc:name "behavior" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:behavior ; - oslc:range oslc_sysml:Behavior ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Behaviors that type this Step."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isImplied a oslc:Property ; - oslc:name "isImplied" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isImplied ; - oslc:readOnly false ; - dcterms:description "Whether this Relationship was generated by tooling to meet semantic rules, rather than being directly created by a modeler."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedRelatedElement a oslc:Property ; - oslc:name "ownedRelatedElement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRelatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElements of this Relationship that are owned by the Relationship."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningRelatedElement a oslc:Property ; - oslc:name "owningRelatedElement" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningRelatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The relatedElement of this Relationship that owns the Relationship, if any."^^rdf:XMLLiteral . - -oslc_sysml_shapes:relatedElement a oslc:Property ; - oslc:name "relatedElement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:relatedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements that are related by this Relationship, derived as the union of the source and target Elements of the Relationship."^^rdf:XMLLiteral . - -oslc_sysml_shapes:direction a oslc:Property ; - oslc:name "direction" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:direction ; - oslc:readOnly false ; - dcterms:description "Indicates how values of this Feature are determined or used (as specified for the FeatureDirectionKind)."^^rdf:XMLLiteral . - -oslc_sysml_shapes:endOwningType a oslc:Property ; - oslc:name "endOwningType" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:endOwningType ; - oslc:range oslc_sysml:Type ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Type that is related to this Feature by an EndFeatureMembership in which the Feature is an ownedMemberFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureTarget a oslc:Property ; - oslc:name "featureTarget" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:featureTarget ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The last of the chainingFeatures of this Feature, if it has any. Otherwise, this Feature itself."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isComposite a oslc:Property ; - oslc:name "isComposite" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isComposite ; - oslc:readOnly false ; - dcterms:description "Whether the Feature is a composite feature of its featuringType. If so, the values of the Feature cannot exist after its featuring instance no longer does."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isDerived a oslc:Property ; - oslc:name "isDerived" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isDerived ; - oslc:readOnly false ; - dcterms:description "Whether the values of this Feature can always be computed from the values of other Features."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isEnd a oslc:Property ; - oslc:name "isEnd" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isEnd ; - oslc:readOnly false ; - dcterms:description "Whether or not the this Feature is an end Feature, requiring a different interpretation of the multiplicity of the Feature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isNonunique a oslc:Property ; - oslc:name "isNonunique" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isNonunique ; - oslc:readOnly false ; - dcterms:description "isNonunique."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isOrdered a oslc:Property ; - oslc:name "isOrdered" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isOrdered ; - oslc:readOnly false ; - dcterms:description "Whether an order exists for the values of this Feature or not."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isPortion a oslc:Property ; - oslc:name "isPortion" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isPortion ; - oslc:readOnly false ; - dcterms:description "Whether the values of this Feature are contained in the space and time of instances of the domain of the Feature and represent the same thing as those instances."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isReadOnly a oslc:Property ; - oslc:name "isReadOnly" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isReadOnly ; - oslc:readOnly false ; - dcterms:description "Whether the values of this Feature can change over the lifetime of an instance of the domain."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isUnique a oslc:Property ; - oslc:name "isUnique" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isUnique ; - oslc:readOnly false ; - dcterms:description "Whether or not values for this Feature must have no duplicates or not."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedFeatureChaining a oslc:Property ; - oslc:name "ownedFeatureChaining" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedFeatureChaining ; - oslc:range oslc_sysml:FeatureChaining ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Feature that are FeatureChainings, for which the Feature will be the featureChained."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedFeatureInverting a oslc:Property ; - oslc:name "ownedFeatureInverting" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedFeatureInverting ; - oslc:range oslc_sysml:FeatureInverting ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Feature that are FeatureInvertings and for which the Feature is the featureInverted."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedRedefinition a oslc:Property ; - oslc:name "ownedRedefinition" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRedefinition ; - oslc:range oslc_sysml:Redefinition ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedSubsettings of this Feature that are Redefinitions, for which the Feature is the redefiningFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedReferenceSubsetting a oslc:Property ; - oslc:name "ownedReferenceSubsetting" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:ownedReferenceSubsetting ; - oslc:range oslc_sysml:ReferenceSubsetting ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The one ownedSubsetting of this Feature, if any, that is a ReferenceSubsetting, for which the Feature is the referencingFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedSubsetting a oslc:Property ; - oslc:name "ownedSubsetting" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedSubsetting ; - oslc:range oslc_sysml:Subsetting ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedSpecializations of this Feature that are Subsettings, for which the Feature is the subsettingFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedTypeFeaturing a oslc:Property ; - oslc:name "ownedTypeFeaturing" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedTypeFeaturing ; - oslc:range oslc_sysml:TypeFeaturing ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Feature that are TypeFeaturings and for which the Feature is the featureOfType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedTyping a oslc:Property ; - oslc:name "ownedTyping" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedTyping ; - oslc:range oslc_sysml:FeatureTyping ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedSpecializations of this Feature that are FeatureTypings, for which the Feature is the typedFeature."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningFeatureMembership a oslc:Property ; - oslc:name "owningFeatureMembership" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningFeatureMembership ; - oslc:range oslc_sysml:FeatureMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The FeatureMembership that owns this Feature as an ownedMemberFeature, determining its owningType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:directedFeature a oslc:Property ; - oslc:name "directedFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:directedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The features of this Type that have a non-null direction."^^rdf:XMLLiteral . - -oslc_sysml_shapes:endFeature a oslc:Property ; - oslc:name "endFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:endFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All features of this Type with isEnd = true."^^rdf:XMLLiteral . - -oslc_sysml_shapes:featureMembership a oslc:Property ; - oslc:name "featureMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:featureMembership ; - oslc:range oslc_sysml:FeatureMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The FeatureMemberships for features of this Type, which include all ownedFeatureMemberships and those inheritedMemberships that are FeatureMemberships (but does not include any importedMemberships)."^^rdf:XMLLiteral . - -oslc_sysml_shapes:inheritedFeature a oslc:Property ; - oslc:name "inheritedFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:inheritedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All the memberFeatures of the inheritedMemberships of this Type that are FeatureMemberships."^^rdf:XMLLiteral . - -oslc_sysml_shapes:inheritedMembership a oslc:Property ; - oslc:name "inheritedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:inheritedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All Memberships inherited by this Type via Specialization or Conjugation. These are included in the derived union for the memberships of the Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:input a oslc:Property ; - oslc:name "input" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:input ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All features related to this Type by FeatureMemberships that have direction in or inout."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isAbstract a oslc:Property ; - oslc:name "isAbstract" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isAbstract ; - oslc:readOnly false ; - dcterms:description "Indicates whether instances of this Type must also be instances of at least one of its specialized Types."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isConjugated a oslc:Property ; - oslc:name "isConjugated" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isConjugated ; - oslc:readOnly false ; - dcterms:description "Indicates whether this Type has an ownedConjugator."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isSufficient a oslc:Property ; - oslc:name "isSufficient" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isSufficient ; - oslc:readOnly false ; - dcterms:description "Whether all things that meet the classification conditions of this Type must be classified by the Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:multiplicity a oslc:Property ; - oslc:name "multiplicity" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:multiplicity ; - oslc:range oslc_sysml:Multiplicity ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "An ownedMember of this Type that is a Multiplicity, which constraints the cardinality of the Type. If there is no such ownedMember, then the cardinality of this Type is constrained by all the Multiplicity constraints applicable to any direct supertypes."^^rdf:XMLLiteral . - -oslc_sysml_shapes:output a oslc:Property ; - oslc:name "output" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:output ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All features related to this Type by FeatureMemberships that have direction out or inout."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedConjugator a oslc:Property ; - oslc:name "ownedConjugator" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:ownedConjugator ; - oslc:range oslc_sysml:Conjugation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "A Conjugation owned by this Type for which the Type is the originalType."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedDifferencing a oslc:Property ; - oslc:name "ownedDifferencing" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedDifferencing ; - oslc:range oslc_sysml:Differencing ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Type that are Differencings, having this Type as their typeDifferenced."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedDisjoining a oslc:Property ; - oslc:name "ownedDisjoining" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedDisjoining ; - oslc:range oslc_sysml:Disjoining ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Type that are Disjoinings, for which the Type is the typeDisjoined Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedEndFeature a oslc:Property ; - oslc:name "ownedEndFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedEndFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All endFeatures of this Type that are ownedFeatures."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedFeature a oslc:Property ; - oslc:name "ownedFeature" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedFeature ; - oslc:range oslc_sysml:Feature ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberFeatures of the ownedFeatureMemberships of this Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedFeatureMembership a oslc:Property ; - oslc:name "ownedFeatureMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedFeatureMembership ; - oslc:range oslc_sysml:FeatureMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedMemberships of this Type that are FeatureMemberships, for which the Type is the owningType. Each such FeatureMembership identifies an ownedFeature of the Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedIntersecting a oslc:Property ; - oslc:name "ownedIntersecting" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedIntersecting ; - oslc:range oslc_sysml:Intersecting ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Type that are Intersectings, have the Type as their typeIntersected."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedSpecialization a oslc:Property ; - oslc:name "ownedSpecialization" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedSpecialization ; - oslc:range oslc_sysml:Specialization ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Type that are Specializations, for which the Type is the specific Type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedUnioning a oslc:Property ; - oslc:name "ownedUnioning" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedUnioning ; - oslc:range oslc_sysml:Unioning ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Type that are Unionings, having the Type as their typeUnioned."^^rdf:XMLLiteral . - -oslc_sysml_shapes:member a oslc:Property ; - oslc:name "member" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:member ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The set of all member Elements of this Namespace, which are the memberElements of all memberships of the Namespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:membership a oslc:Property ; - oslc:name "membership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:membership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "All Memberships in this Namespace, including (at least) the union of ownedMemberships and importedMemberships."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedImport a oslc:Property ; - oslc:name "ownedImport" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedImport ; - oslc:range oslc_sysml:Import ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Namespace that are Imports, for which the Namespace is the importOwningNamespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMember a oslc:Property ; - oslc:name "ownedMember" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedMember ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owned members of this Namespace, which are the ownedMemberElements of the ownedMemberships of the Namespace.."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedMembership a oslc:Property ; - oslc:name "ownedMembership" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedMembership ; - oslc:range oslc_sysml:Membership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Namespace that are Memberships, for which the Namespace is the membershipOwningNamespace."^^rdf:XMLLiteral . - -oslc_sysml_shapes:aliasIds a oslc:Property ; - oslc:name "aliasIds" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:aliasIds ; - oslc:readOnly false ; - dcterms:description "Various alternative identifiers for this Element. Generally, these will be set by tools."^^rdf:XMLLiteral . - -oslc_sysml_shapes:contributor a oslc:Property ; - oslc:name "contributor" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition dcterms:contributor ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:AnyResource ; - dcterms:description "Contributor or contributors to the resource. It is likely that the target resource will be a foaf:Person but that is not necessarily the case."^^rdf:XMLLiteral . - -oslc_sysml_shapes:created a oslc:Property ; - oslc:name "created" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition dcterms:created ; - oslc:readOnly false ; - oslc:valueType xsd:dateTime ; - dcterms:description "Timestamp of resource creation."^^rdf:XMLLiteral . - -oslc_sysml_shapes:creator a oslc:Property ; - oslc:name "creator" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition dcterms:creator ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:AnyResource ; - dcterms:description "Creator or creators of the resource. It is likely that the target resource will be a foaf:Person but that is not necessarily the case."^^rdf:XMLLiteral . - -oslc_sysml_shapes:dctype a oslc:Property ; - oslc:name "dctype" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition dcterms:type ; - oslc:readOnly false ; - oslc:valueType xsd:string ; - dcterms:description "A short string representation for the type, for example ‘Car’."^^rdf:XMLLiteral . - -oslc_sysml_shapes:declaredName a oslc:Property ; - oslc:name "declaredName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:declaredName ; - oslc:readOnly false ; - dcterms:description "The declared name of this Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:declaredShortName a oslc:Property ; - oslc:name "declaredShortName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:declaredShortName ; - oslc:readOnly false ; - dcterms:description "An optional alternative name for the Element that is intended to be shorter or in some way more succinct than its primary name. It may act as a modeler-specified identifier for the Element, though it is then the responsibility of the modeler to maintain the uniqueness of this identifier within a model or relative to some other context."^^rdf:XMLLiteral . - -oslc_sysml_shapes:derives a oslc:Property ; - oslc:name "derives" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:derives ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """The resource that derives from another resource originated from or is -significantly influenced by the referenced resource. For example a model element derives from a -requirement."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:description a oslc:Property ; - oslc:name "description" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition dcterms:description ; - oslc:readOnly false ; - oslc:valueType rdf:XMLLiteral ; - dcterms:description "Descriptive text about resource represented as rich text in XHTML content."^^rdf:XMLLiteral . - -oslc_sysml_shapes:documentation a oslc:Property ; - oslc:name "documentation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:documentation ; - oslc:range oslc_sysml:Documentation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Documentation owned by this Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:elaborates a oslc:Property ; - oslc:name "elaborates" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:elaborates ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description "This resource elaborates the referenced resource."^^rdf:XMLLiteral . - -oslc_sysml_shapes:elementId a oslc:Property ; - oslc:name "elementId" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:elementId ; - oslc:readOnly false ; - dcterms:description "The globally unique identifier for this Element. This is intended to be set by tooling, and it must not change during the lifetime of the Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:external a oslc:Property ; - oslc:name "external" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:external ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description "A generic link from a resource to an external web page."^^rdf:XMLLiteral . - -oslc_sysml_shapes:identifier a oslc:Property ; - oslc:name "identifier" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition dcterms:identifier ; - oslc:readOnly true ; - oslc:valueType xsd:string ; - dcterms:description """A unique identifier for a resource. Typically read-only and assigned by the -service provider when a resource is created. Not typically intended for end-user display."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:instanceShape a oslc:Property ; - oslc:name "instanceShape" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc:instanceShape ; - oslc:range oslc:ResourceShape ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """The URI of a Resource Shape that describes the possible properties, occurrence, -value types, allowed values and labels. This shape information is useful in displaying the subject -resource as well as guiding clients in performing modifications. Instance shapes may be specific -to the authenticated user associated with the request that retrieved the resource, the current -state of the resource and other factors and thus should not be cached."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:isImpliedIncluded a oslc:Property ; - oslc:name "isImpliedIncluded" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isImpliedIncluded ; - oslc:readOnly false ; - dcterms:description "Whether all necessary implied Relationships have been included in the ownedRelationships of this Element. This property may be true, even if there are not actually any ownedRelationships with isImplied = true, meaning that no such Relationships are actually implied for this Element. However, if it is false, then ownedRelationships may not contain any implied Relationships. That is, either all required implied Relationships must be included, or none of them."^^rdf:XMLLiteral . - -oslc_sysml_shapes:isLibraryElement a oslc:Property ; - oslc:name "isLibraryElement" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition oslc_sysml:isLibraryElement ; - oslc:readOnly false ; - dcterms:description "Whether this Element is contained in the ownership tree of a library model."^^rdf:XMLLiteral . - -oslc_sysml_shapes:modified a oslc:Property ; - oslc:name "modified" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition dcterms:modified ; - oslc:readOnly false ; - oslc:valueType xsd:dateTime ; - dcterms:description "Timestamp of latest resource modification."^^rdf:XMLLiteral . - -oslc_sysml_shapes:name a oslc:Property ; - oslc:name "name" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:name ; - oslc:readOnly false ; - dcterms:description "The name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveName() operation. By default, it is the same as the declaredName, but this is overridden for certain kinds of Elements to compute a name even when the declaredName is null."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedAnnotation a oslc:Property ; - oslc:name "ownedAnnotation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedAnnotation ; - oslc:range oslc_sysml:Annotation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The ownedRelationships of this Element that are Annotations, for which this Element is the annotatedElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedElement a oslc:Property ; - oslc:name "ownedElement" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedElement ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Elements owned by this Element, derived as the ownedRelatedElements of the ownedRelationships of this Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:ownedRelationship a oslc:Property ; - oslc:name "ownedRelationship" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:ownedRelationship ; - oslc:range oslc_sysml:Relationship ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Relationships for which this Element is the owningRelatedElement."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owner a oslc:Property ; - oslc:name "owner" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owner ; - oslc:range oslc_sysml:Element ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owner of this Element, derived as the owningRelatedElement of the owningRelationship of this Element, if any."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningMembership a oslc:Property ; - oslc:name "owningMembership" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningMembership ; - oslc:range oslc_sysml:OwningMembership ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The owningRelationship of this Element, if that Relationship is a Membership."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningNamespace a oslc:Property ; - oslc:name "owningNamespace" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningNamespace ; - oslc:range oslc_sysml:Namespace ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Namespace that owns this Element, which is the membershipOwningNamespace of the owningMembership of this Element, if any."^^rdf:XMLLiteral . - -oslc_sysml_shapes:owningRelationship a oslc:Property ; - oslc:name "owningRelationship" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:owningRelationship ; - oslc:range oslc_sysml:Relationship ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The Relationship for which this Element is an ownedRelatedElement, if any."^^rdf:XMLLiteral . - -oslc_sysml_shapes:qualifiedName a oslc:Property ; - oslc:name "qualifiedName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:qualifiedName ; - oslc:readOnly false ; - dcterms:description "The full ownership-qualified name of this Element, represented in a form that is valid according to the KerML textual concrete syntax for qualified names (including use of unrestricted name notation and escaped characters, as necessary). The qualifiedName is null if this Element has no owningNamespace or if there is not a complete ownership chain of named Namespaces from a root Namespace to this Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:refine a oslc:Property ; - oslc:name "refine" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:refine ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """The target is a refinement of the source. (e.g. a use case scenario -might be a refinement of a textual requirement that describes the interaction)."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:satisfy a oslc:Property ; - oslc:name "satisfy" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:satisfy ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """The model element satisfies the requirement (e.g. The use case -satisfies a functional requirement)."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:serviceProvider a oslc:Property ; - oslc:name "serviceProvider" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc:serviceProvider ; - oslc:range oslc:ServiceProvider ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """A link to the resource's OSLC Service Provider. There may be cases when the -subject resource is available from a service provider that implements multiple domain -specifications, which could result in multiple values for this property."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:shortName a oslc:Property ; - oslc:name "shortName" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc_sysml:shortName ; - oslc:readOnly false ; - dcterms:description "The short name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveShortName() operation. By default, it is the same as the declaredShortName, but this is overridden for certain kinds of Elements to compute a shortName even when the declaredName is null."^^rdf:XMLLiteral . - -oslc_sysml_shapes:shortTitle a oslc:Property ; - oslc:name "shortTitle" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition oslc:shortTitle ; - oslc:readOnly false ; - oslc:valueType rdf:XMLLiteral ; - dcterms:description "{{Short name identifying a resource, often used as an abbreviated identifier for presentation to end-users. SHOULD include only content that is valid inside an XHTML <span> element}}."^^rdf:XMLLiteral . - -oslc_sysml_shapes:source a oslc:Property ; - oslc:name "source" ; - oslc:occurs oslc:Zero-or-one ; - oslc:propertyDefinition dcterms:source ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description "The resource URI a client can perform a get on to obtain the original non-OSLC AM formatted resource that was used to create this resource. The source resource is usually a binary or proprietary format that the service provider can consume and convert into an OSLC AM format. The service may use content negotiation with the Accept header to obtain the desired content type."^^rdf:XMLLiteral . - -oslc_sysml_shapes:textualRepresentation a oslc:Property ; - oslc:name "textualRepresentation" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition oslc_sysml:textualRepresentation ; - oslc:range oslc_sysml:TextualRepresentation ; - oslc:readOnly false ; - oslc:representation oslc:Either ; - oslc:valueType oslc:Resource ; - dcterms:description "The TextualRepresentations that annotate this Element."^^rdf:XMLLiteral . - -oslc_sysml_shapes:title a oslc:Property ; - oslc:name "title" ; - oslc:occurs oslc:Exactly-one ; - oslc:propertyDefinition dcterms:title ; - oslc:readOnly false ; - oslc:valueType rdf:XMLLiteral ; - dcterms:description "Title of the resource represented as rich text in XHTML content."^^rdf:XMLLiteral . - -oslc_sysml_shapes:trace a oslc:Property ; - oslc:name "trace" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition jazz_am:trace ; - oslc:range oslc:Any ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description """The model element has a trace to the requirement (e.g. An attribute -or its value are traced to a requirement)."""^^rdf:XMLLiteral . - -oslc_sysml_shapes:type a oslc:Property ; - oslc:name "type" ; - oslc:occurs oslc:Zero-or-many ; - oslc:propertyDefinition rdf:type ; - oslc:range rdfs:Class ; - oslc:readOnly false ; - oslc:representation oslc:Reference ; - oslc:valueType oslc:Resource ; - dcterms:description "The resource type URIs."^^rdf:XMLLiteral . - diff --git a/specs/sysml/sysml-spec.html b/specs/sysml/sysml-spec.html index 903e272..8e6d154 100644 --- a/specs/sysml/sysml-spec.html +++ b/specs/sysml/sysml-spec.html @@ -69,11 +69,11 @@ }, { title: "OSLC SysML Version 2.0. Part 4: Machine Readable Vocabulary Terms", - href: "sysml-vocab.ttl", + href: "SysML-Vocabulary-vocab.ttl", }, { title: "OSLC SysML Version 2.0. Part 5: Machine Readable Constraints", - href: "sysml-shapes.ttl", + href: "SysML-Shapes-shapes.ttl", }, ], diff --git a/specs/sysml/sysml-vocab.html b/specs/sysml/sysml-vocab.html index 174921a..0b7415e 100644 --- a/specs/sysml/sysml-vocab.html +++ b/specs/sysml/sysml-vocab.html @@ -65,11 +65,11 @@ }, { title: "OSLC SysML Version 2.0. Part 4: Machine Readable Vocabulary Terms", - href: "sysml-vocab.ttl", + href: "SysML-Vocabulary-vocab.ttl", }, { title: "OSLC SysML Version 2.0. Part 5: Machine Readable Constraints", - href: "sysml-shapes.ttl", + href: "SysML-Shapes-shapes.ttl", }, ], @@ -322,7 +322,7 @@

SysML v2 Vocabulary Terms

. -@prefix oslc_am: . -@prefix oslc_sysml: . -@prefix owl: . -@prefix rdf: . -@prefix rdfs: . -@prefix vann: . -@prefix xsd: . - -oslc_sysml:AcceptActionUsage a rdfs:Class ; - rdfs:label "AcceptActionUsage" ; - rdfs:comment "An AcceptActionUsage is an ActionUsage that specifies the acceptance of an incomingTransfer from the Occurrence given by the result of its receiverArgument Expression. (If no receiverArgument is provided, the default is the this context of the AcceptActionUsage.) The payload of the accepted Transfer is output on its payloadParameter. Which Transfers may be accepted is determined by conformance to the typing and (potentially) binding of the payloadParameter." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:ActionDefinition a rdfs:Class ; - rdfs:label "ActionDefinition" ; - rdfs:comment "An ActionDefinition is a Definition that is also a Behavior that defines an Action performed by a system or part of a system." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Behavior, - oslc_sysml:OccurrenceDefinition . - -oslc_sysml:ActionUsage a rdfs:Class ; - rdfs:label "ActionUsage" ; - rdfs:comment "An ActionUsage is a Usage that is also a Step, and, so, is typed by a Behavior. Nominally, if the type is an ActionDefinition, an ActionUsage is a Usage of that ActionDefinition within a system. However, other kinds of kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceUsage, - oslc_sysml:Step . - -oslc_sysml:ActorMembership a rdfs:Class ; - rdfs:label "ActorMembership" ; - rdfs:comment "An ActorMembership is a ParameterMembership that identifies a PartUsage as an actor parameter, which specifies a role played by an external entity in interaction with the owningType of the ActorMembership." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ParameterMembership . - -oslc_sysml:AllocationDefinition a rdfs:Class ; - rdfs:label "AllocationDefinition" ; - rdfs:comment "An AllocationDefinition is a ConnectionDefinition that specifies that some or all of the responsibility to realize the intent of the source is allocated to the target instances. Such allocations define mappings across the various structures and hierarchies of a system model, perhaps as a precursor to more rigorous specifications and implementations. An AllocationDefinition can itself be refined using nested allocations that give a finer-grained decomposition of the containing allocation mapping." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectionDefinition . - -oslc_sysml:AllocationUsage a rdfs:Class ; - rdfs:label "AllocationUsage" ; - rdfs:comment "An AllocationUsage is a usage of an AllocationDefinition asserting the allocation of the source feature to the target feature." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectionUsage . - -oslc_sysml:AnalysisCaseDefinition a rdfs:Class ; - rdfs:label "AnalysisCaseDefinition" ; - rdfs:comment "An AnalysisCaseDefinition is a CaseDefinition for the case of carrying out an analysis." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseDefinition . - -oslc_sysml:AnalysisCaseUsage a rdfs:Class ; - rdfs:label "AnalysisCaseUsage" ; - rdfs:comment "An AnalysisCaseUsage is a Usage of an AnalysisCaseDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseUsage . - -oslc_sysml:AnnotatingElement a rdfs:Class ; - rdfs:label "AnnotatingElement" ; - rdfs:comment "An AnnotatingElement is an Element that provides additional description of or metadata on some other Element. An AnnotatingElement is either attached to its annotatedElements by Annotation Relationships, or it implicitly annotates its owningNamespace." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Element . - -oslc_sysml:Annotation a rdfs:Class ; - rdfs:label "Annotation" ; - rdfs:comment "An Annotation is a Relationship between an AnnotatingElement and the Element that is annotated by that AnnotatingElement." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:AssertConstraintUsage a rdfs:Class ; - rdfs:label "AssertConstraintUsage" ; - rdfs:comment "An AssertConstraintUsage is a ConstraintUsage that is also an Invariant and, so, is asserted to be true (by default). Unless it is the AssertConstraintUsage itself, the asserted ConstraintUsage is related to the AssertConstraintUsage by a ReferenceSubsetting Relationship." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConstraintUsage, - oslc_sysml:Invariant . - -oslc_sysml:AssignmentActionUsage a rdfs:Class ; - rdfs:label "AssignmentActionUsage" ; - rdfs:comment "An AssignmentActionUsage is an ActionUsage that is defined, directly or indirectly, by the ActionDefinition AssignmentAction from the Systems Model Library. It specifies that the value of the referent Feature, relative to the target given by the result of the targetArgument Expression, should be set to the result of the valueExpression." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:Association a rdfs:Class ; - rdfs:label "Association" ; - rdfs:comment "An Association is a Relationship and a Classifier to enable classification of links between things (in the universe). The co-domains (types) of the associationEnd Features are the relatedTypes, as co-domain and participants (linked things) of an Association identify each other." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Classifier, - oslc_sysml:Relationship . - -oslc_sysml:AssociationStructure a rdfs:Class ; - rdfs:label "AssociationStructure" ; - rdfs:comment "An AssociationStructure is an Association that is also a Structure, classifying link objects that are both links and objects. As objects, link objects can be created and destroyed, and their non-end Features can change over time. However, the values of the end Features of a link object are fixed and cannot change over its lifetime." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Association, - oslc_sysml:Structure . - -oslc_sysml:AttributeDefinition a rdfs:Class ; - rdfs:label "AttributeDefinition" ; - rdfs:comment "An AttributeDefinition is a Definition and a DataType of information about a quality or characteristic of a system or part of a system that has no independent identity other than its value. All features of an AttributeDefinition must be referential (non-composite)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:DataType, - oslc_sysml:Definition . - -oslc_sysml:AttributeUsage a rdfs:Class ; - rdfs:label "AttributeUsage" ; - rdfs:comment "An AttributeUsage is a Usage whose type is a DataType. Nominally, if the type is an AttributeDefinition, an AttributeUsage is a usage of a AttributeDefinition to represent the value of some system quality or characteristic. However, other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries. An AttributeUsage itself as well as all its nested features must be referential (non-composite)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Usage . - -oslc_sysml:Behavior a rdfs:Class ; - rdfs:label "Behavior" ; - rdfs:comment "A Behavior coordinates occurrences of other Behaviors, as well as changes in objects. Behaviors can be decomposed into Steps and be characterized by parameters." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Class . - -oslc_sysml:BindingConnector a rdfs:Class ; - rdfs:label "BindingConnector" ; - rdfs:comment "A BindingConnector is a binary Connector that requires its relatedFeatures to identify the same things (have the same values)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Connector . - -oslc_sysml:BindingConnectorAsUsage a rdfs:Class ; - rdfs:label "BindingConnectorAsUsage" ; - rdfs:comment "A BindingConnectorAsUsage is both a BindingConnector and a ConnectorAsUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:BindingConnector, - oslc_sysml:ConnectorAsUsage . - -oslc_sysml:BooleanExpression a rdfs:Class ; - rdfs:label "BooleanExpression" ; - rdfs:comment "A BooleanExpression is a Boolean-valued Expression whose type is a Predicate. It represents a logical condition resulting from the evaluation of the Predicate." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:CalculationDefinition a rdfs:Class ; - rdfs:label "CalculationDefinition" ; - rdfs:comment "A CalculationDefinition is an ActionDefinition that also defines a Function producing a result." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionDefinition, - oslc_sysml:Function . - -oslc_sysml:CalculationUsage a rdfs:Class ; - rdfs:label "CalculationUsage" ; - rdfs:comment "A CalculationUsage is an ActionUsage that is also an Expression, and, so, is typed by a Function. Nominally, if the type is a CalculationDefinition, a CalculationUsage is a Usage of that CalculationDefinition within a system. However, other kinds of kernel Functions are also allowed, to permit use of Functions from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage, - oslc_sysml:Expression . - -oslc_sysml:CaseDefinition a rdfs:Class ; - rdfs:label "CaseDefinition" ; - rdfs:comment "A CaseDefinition is a CalculationDefinition for a process, often involving collecting evidence or data, relative to a subject, possibly involving the collaboration of one or more other actors, producing a result that meets an objective." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CalculationDefinition . - -oslc_sysml:CaseUsage a rdfs:Class ; - rdfs:label "CaseUsage" ; - rdfs:comment "A CaseUsage is a Usage of a CaseDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CalculationUsage . - -oslc_sysml:Class a rdfs:Class ; - rdfs:label "Class" ; - rdfs:comment "A Class is a Classifier of things (in the universe) that can be distinguished without regard to how they are related to other things (via Features). This means multiple things classified by the same Class can be distinguished, even when they are related other things in exactly the same way." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Classifier . - -oslc_sysml:Classifier a rdfs:Class ; - rdfs:label "Classifier" ; - rdfs:comment "A Classifier is a Type that classifies:." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Type . - -oslc_sysml:CollectExpression a rdfs:Class ; - rdfs:label "CollectExpression" ; - rdfs:comment "A CollectExpression is an OperatorExpression whose operator is \"collect\", which resolves to the Function ControlFunctions::collect from the Kernel Functions Library." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OperatorExpression . - -oslc_sysml:Comment a rdfs:Class ; - rdfs:label "Comment" ; - rdfs:comment "A Comment is an AnnotatingElement whose body in some way describes its annotatedElements." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AnnotatingElement . - -oslc_sysml:ConcernDefinition a rdfs:Class ; - rdfs:label "ConcernDefinition" ; - rdfs:comment "A ConcernDefinition is a RequirementDefinition that one or more stakeholders may be interested in having addressed. These stakeholders are identified by the ownedStakeholdersof the ConcernDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementDefinition . - -oslc_sysml:ConcernUsage a rdfs:Class ; - rdfs:label "ConcernUsage" ; - rdfs:comment "A ConcernUsage is a Usage of a ConcernDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementUsage . - -oslc_sysml:ConjugatedPortDefinition a rdfs:Class ; - rdfs:label "ConjugatedPortDefinition" ; - rdfs:comment "A ConjugatedPortDefinition is a PortDefinition that is a PortDefinition of its original PortDefinition. That is, a ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition. Every PortDefinition (that is not itself a ConjugatedPortDefinition) has exactly one corresponding ConjugatedPortDefinition, whose effective name is the name of the originalPortDefinition, with the character ~ prepended." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PortDefinition . - -oslc_sysml:ConjugatedPortTyping a rdfs:Class ; - rdfs:label "ConjugatedPortTyping" ; - rdfs:comment "A ConjugatedPortTyping is a FeatureTyping whose type is a ConjugatedPortDefinition. (This relationship is intended to be an abstract-syntax marker for a special surface notation for conjugated typing of ports.)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureTyping . - -oslc_sysml:Conjugation a rdfs:Class ; - rdfs:label "Conjugation" ; - rdfs:comment "Conjugation is a Relationship between two types in which the conjugatedType inherits all the Features of the originalType, but with all input and output Features reversed. That is, any Features with a direction in relative to the originalType are considered to have an effective direction of out relative to the conjugatedType and, similarly, Features with direction out in the originalType are considered to have an effective direction of in in the conjugatedType. Features with direction inout, or with no direction, in the originalType, are inherited without change." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:ConnectionDefinition a rdfs:Class ; - rdfs:label "ConnectionDefinition" ; - rdfs:comment "A ConnectionDefinition is a PartDefinition that is also an AssociationStructure. The end Features of a ConnectionDefinition must be Usages." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AssociationStructure, - oslc_sysml:PartDefinition . - -oslc_sysml:ConnectionUsage a rdfs:Class ; - rdfs:label "ConnectionUsage" ; - rdfs:comment "A ConnectionUsage is a ConnectorAsUsage that is also a PartUsage. Nominally, if its type is a ConnectionDefinition, then a ConnectionUsage is a Usage of that ConnectionDefinition, representing a connection between parts of a system. However, other kinds of kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectorAsUsage, - oslc_sysml:PartUsage . - -oslc_sysml:Connector a rdfs:Class ; - rdfs:label "Connector" ; - rdfs:comment "A Connector is a usage of Associations, with links restricted according to instances of the Type in which they are used (domain of the Connector). The associations of the Connector restrict what kinds of things might be linked. The Connector further restricts these links to be between values of Features on instances of its domain." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature, - oslc_sysml:Relationship . - -oslc_sysml:ConnectorAsUsage a rdfs:Class ; - rdfs:label "ConnectorAsUsage" ; - rdfs:comment "A ConnectorAsUsage is both a Connector and a Usage. ConnectorAsUsage cannot itself be instantiated in a SysML model, but it is the base class for the concrete classes BindingConnectorAsUsage, SuccessionAsUsage and ConnectionUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Connector, - oslc_sysml:Usage . - -oslc_sysml:ConstraintDefinition a rdfs:Class ; - rdfs:label "ConstraintDefinition" ; - rdfs:comment "A ConstraintDefinition is an OccurrenceDefinition that is also a Predicate that defines a constraint that may be asserted to hold on a system or part of a system." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceDefinition, - oslc_sysml:Predicate . - -oslc_sysml:ConstraintUsage a rdfs:Class ; - rdfs:label "ConstraintUsage" ; - rdfs:comment "A ConstraintUsage is an OccurrenceUsage that is also a BooleanExpression, and, so, is typed by a Predicate. Nominally, if the type is a ConstraintDefinition, a ConstraintUsage is a Usage of that ConstraintDefinition. However, other kinds of kernel Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:BooleanExpression, - oslc_sysml:OccurrenceUsage . - -oslc_sysml:ControlNode a rdfs:Class ; - rdfs:label "ControlNode" ; - rdfs:comment "A ControlNode is an ActionUsage that does not have any inherent behavior but provides constraints on incoming and outgoing Successions that are used to control other Actions. A ControlNode must be a composite owned usage of an ActionDefinition or ActionUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:DataType a rdfs:Class ; - rdfs:label "DataType" ; - rdfs:comment "A DataType is a Classifier of things (in the universe) that can only be distinguished by how they are related to other things (via Features). This means multiple things classified by the same DataType." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Classifier . - -oslc_sysml:DecisionNode a rdfs:Class ; - rdfs:label "DecisionNode" ; - rdfs:comment "A DecisionNode is a ControlNode that makes a selection from its outgoing Successions." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ControlNode . - -oslc_sysml:Definition a rdfs:Class ; - rdfs:label "Definition" ; - rdfs:comment "A Definition is a Classifier of Usages. The actual kinds of Definition that may appear in a model are given by the subclasses of Definition (possibly as extended with user-defined SemanticMetadata)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Classifier . - -oslc_sysml:Dependency a rdfs:Class ; - rdfs:label "Dependency" ; - rdfs:comment "A Dependency is a Relationship that indicates that one or more client Elements require one more supplier Elements for their complete specification. In general, this means that a change to one of the supplier Elements may necessitate a change to, or re-specification of, the client Elements." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:Differencing a rdfs:Class ; - rdfs:label "Differencing" ; - rdfs:comment "Differencing is a Relationship that makes its differencingType one of the differencingTypes of its typeDifferenced." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:Disjoining a rdfs:Class ; - rdfs:label "Disjoining" ; - rdfs:comment "A Disjoining is a Relationship between Types asserted to have interpretations that are not shared (disjoint) between them, identified as typeDisjoined and disjoiningType. For example, a Classifier for mammals is disjoint from a Classifier for minerals, and a Feature for people's parents is disjoint from a Feature for their children." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:Documentation a rdfs:Class ; - rdfs:label "Documentation" ; - rdfs:comment "Documentation is a Comment that specifically documents a documentedElement, which must be its owner." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Comment . - -oslc_sysml:Element a rdfs:Class ; - rdfs:label "Element" ; - rdfs:comment "An Element is a constituent of a model that is uniquely identified relative to all other Elements. It can have Relationships with other Elements. Some of these Relationships might imply ownership of other Elements, which means that if an Element is deleted from a model, then so are all the Elements that it owns." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_am:Resource . - -oslc_sysml:ElementFilterMembership a rdfs:Class ; - rdfs:label "ElementFilterMembership" ; - rdfs:comment "ElementFilterMembership is a Membership between a Namespace and a model-level evaluable Boolean-valued Expression, asserting that imported members of the Namespace should be filtered using the condition Expression. A general Namespace does not define any specific filtering behavior, but such behavior may be defined for various specialized kinds of Namespaces." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OwningMembership . - -oslc_sysml:EndFeatureMembership a rdfs:Class ; - rdfs:label "EndFeatureMembership" ; - rdfs:comment "EndFeatureMembership is a FeatureMembership that requires its memberFeature be owned and have isEnd = true." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:EnumerationDefinition a rdfs:Class ; - rdfs:label "EnumerationDefinition" ; - rdfs:comment "An EnumerationDefinition is an AttributeDefinition all of whose instances are given by an explicit list of enumeratedValues. This is realized by requiring that the EnumerationDefinition have isVariation = true, with the enumeratedValues being its variants." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AttributeDefinition . - -oslc_sysml:EnumerationUsage a rdfs:Class ; - rdfs:label "EnumerationUsage" ; - rdfs:comment "An EnumerationUsage is an AttributeUsage whose attributeDefinition is an EnumerationDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AttributeUsage . - -oslc_sysml:EventOccurrenceUsage a rdfs:Class ; - rdfs:label "EventOccurrenceUsage" ; - rdfs:comment "An EventOccurrenceUsage is an OccurrenceUsage that represents another OccurrenceUsage occurring as a suboccurrence of the containing occurrence of the EventOccurrenceUsage. Unless it is the EventOccurrenceUsage itself, the referenced OccurrenceUsage is related to the EventOccurrenceUsage by a ReferenceSubsetting Relationship." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceUsage . - -oslc_sysml:ExhibitStateUsage a rdfs:Class ; - rdfs:label "ExhibitStateUsage" ; - rdfs:comment "An ExhibitStateUsage is a StateUsage that represents the exhibiting of a StateUsage. Unless it is the StateUsage itself, the StateUsage to be exhibited is related to the ExhibitStateUsage by a ReferenceSubsetting Relationship. An ExhibitStateUsage is also a PerformActionUsage, with its exhibitedState as the performedAction." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PerformActionUsage, - oslc_sysml:StateUsage . - -oslc_sysml:Expose a rdfs:Class ; - rdfs:label "Expose" ; - rdfs:comment "An Expose is an Import of Memberships into a ViewUsage that provide the Elements to be included in a view. Visibility is always ignored for an Expose (i.e., isImportAll = true)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Import . - -oslc_sysml:Expression a rdfs:Class ; - rdfs:label "Expression" ; - rdfs:comment "An Expression is a Step that is typed by a Function. An Expression that also has a Function as its featuringType is a computational step within that Function. An Expression always has a single result parameter, which redefines the result parameter of its defining function. This allows Expressions to be interconnected in tree structures, in which inputs to each Expression in the tree are determined as the results of other Expression in the tree." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Step . - -oslc_sysml:Feature a rdfs:Class ; - rdfs:label "Feature" ; - rdfs:comment """A Feature is a Type that classifies relations between multiple things (in the universe). The domain of the relation is the intersection of the featuringTypes of the Feature. (The domain of a Feature with no featuringTyps is implicitly the most general Type Base::Anything from the Kernel Semantic Library.) The co-domain of the relation is the intersection of the types of the Feature. - -.""" ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Type . - -oslc_sysml:FeatureChainExpression a rdfs:Class ; - rdfs:label "FeatureChainExpression" ; - rdfs:comment "A FeatureChainExpression is an OperatorExpression whose operator is \".\", which resolves to the Function ControlFunctions::'.' from the Kernel Functions Library. It evaluates to the result of chaining the result Feature of its single argument Expression with its targetFeature." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OperatorExpression . - -oslc_sysml:FeatureChaining a rdfs:Class ; - rdfs:label "FeatureChaining" ; - rdfs:comment "FeatureChaining is a Relationship that makes its target Feature one of the chainingFeatures of its owning Feature." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:FeatureDirectionKind a rdfs:Class ; - rdfs:label "FeatureDirectionKind" ; - rdfs:comment "FeatureDirectionKind enumerates the possible kinds of direction that a Feature may be given as a member of a Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:FeatureInverting a rdfs:Class ; - rdfs:label "FeatureInverting" ; - rdfs:comment "A FeatureInverting is a Relationship between Features asserting that their interpretations (sequences) are the reverse of each other, identified as featureInverted and invertingFeature. For example, a Feature identifying each person's parents is the inverse of a Feature identifying each person's children. A person identified as a parent of another will identify that other as one of their children." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:FeatureMembership a rdfs:Class ; - rdfs:label "FeatureMembership" ; - rdfs:comment "A FeatureMembership is an OwningMembership between a Feature in an owningType that is also a Featuring Relationship between the Feature and the Type, in which the featuringType is the source and the featureOfType is the target. A FeatureMembership is always owned by its owningType, which is the featuringType for the FeatureMembership considered as a Featuring." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Featuring, - oslc_sysml:OwningMembership . - -oslc_sysml:FeatureReferenceExpression a rdfs:Class ; - rdfs:label "FeatureReferenceExpression" ; - rdfs:comment "A FeatureReferenceExpression is an Expression whose result is bound to a referent Feature." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:FeatureTyping a rdfs:Class ; - rdfs:label "FeatureTyping" ; - rdfs:comment "FeatureTyping is Specialization in which the specific Type is a Feature. This means the set of instances of the (specific) typedFeature is a subset of the set of instances of the (general) type. In the simplest case, the type is a Classifier, whereupon the typedFeature has values that are instances of the Classifier." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Specialization . - -oslc_sysml:FeatureValue a rdfs:Class ; - rdfs:label "FeatureValue" ; - rdfs:comment "A FeatureValue is a Membership that identifies a particular member Expression that provides the value of the Feature that owns the FeatureValue. The value is specified as either a bound value or an initial value, and as either a concrete or default value. A Feature can have at most one FeatureValue." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OwningMembership . - -oslc_sysml:Featuring a rdfs:Class ; - rdfs:label "Featuring" ; - rdfs:comment "Featuring is a Relationship between a Type and a Feature that is featured by that Type. It asserts that every instance in the domain of the feature must be classified by the type." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:FlowConnectionDefinition a rdfs:Class ; - rdfs:label "FlowConnectionDefinition" ; - rdfs:comment "A FlowConnectionDefinition is a ConnectionDefinition and ActionDefinition that is also an Interaction representing flows between Usages." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionDefinition, - oslc_sysml:ConnectionDefinition, - oslc_sysml:Interaction . - -oslc_sysml:FlowConnectionUsage a rdfs:Class ; - rdfs:label "FlowConnectionUsage" ; - rdfs:comment "A FlowConnectionUsage is a ConnectionUsage that is also an ItemFlow." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage, - oslc_sysml:ConnectionUsage, - oslc_sysml:ItemFlow . - -oslc_sysml:ForLoopActionUsage a rdfs:Class ; - rdfs:label "ForLoopActionUsage" ; - rdfs:comment "A ForLoopActionUsage is a LoopActionUsage that specifies that its bodyAction ActionUsage should be performed once for each value, in order, from the sequence of values obtained as the result of the seqArgument Expression, with the loopVariable set to the value for each iteration." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LoopActionUsage . - -oslc_sysml:ForkNode a rdfs:Class ; - rdfs:label "ForkNode" ; - rdfs:comment "A ForkNode is a ControlNode that must be followed by successor Actions as given by all its outgoing Successions." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ControlNode . - -oslc_sysml:FramedConcernMembership a rdfs:Class ; - rdfs:label "FramedConcernMembership" ; - rdfs:comment "A FramedConcernMembership is a RequirementConstraintMembership for a framed ConcernUsage of a RequirementDefinition or RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementConstraintMembership . - -oslc_sysml:Function a rdfs:Class ; - rdfs:label "Function" ; - rdfs:comment "A Function is a Behavior that has an out parameter that is identified as its result. A Function represents the performance of a calculation that produces the values of its result parameter. This calculation may be decomposed into Expressions that are steps of the Function." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Behavior . - -oslc_sysml:IfActionUsage a rdfs:Class ; - rdfs:label "IfActionUsage" ; - rdfs:comment "An IfActionUsage is an ActionUsage that specifies that the thenAction ActionUsage should be performed if the result of the ifArgument Expression is true. It may also optionally specify an elseAction ActionUsage that is performed if the result of the ifArgument is false." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:Import a rdfs:Class ; - rdfs:label "Import" ; - rdfs:comment "An Import is an Relationship between its importOwningNamespace and either a Membership (for a MembershipImport) or another Namespace (for a NamespaceImport), which determines a set of Memberships that become importedMemberships of the importOwningNamespace. If isImportAll = false (the default), then only public Memberships are considered \"visible\". If isImportAll = true, then all Memberships are considered \"visible\", regardless of their declared visibility. If isRecursive = true, then visible Memberships are also recursively imported from owned sub-Namespaces." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:IncludeUseCaseUsage a rdfs:Class ; - rdfs:label "IncludeUseCaseUsage" ; - rdfs:comment "An IncludeUseCaseUsage is a UseCaseUsage that represents the inclusion of a UseCaseUsage by a UseCaseDefinition or UseCaseUsage. Unless it is the IncludeUseCaseUsage itself, the UseCaseUsage to be included is related to the includedUseCase by a ReferenceSubsetting Relationship. An IncludeUseCaseUsage is also a PerformActionUsage, with its useCaseIncluded as the performedAction." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PerformActionUsage, - oslc_sysml:UseCaseUsage . - -oslc_sysml:Interaction a rdfs:Class ; - rdfs:label "Interaction" ; - rdfs:comment "An Interaction is a Behavior that is also an Association, providing a context for multiple objects that have behaviors that impact one another." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Association, - oslc_sysml:Behavior . - -oslc_sysml:InterfaceDefinition a rdfs:Class ; - rdfs:label "InterfaceDefinition" ; - rdfs:comment "An InterfaceDefinition is a ConnectionDefinition all of whose ends are PortUsages, defining an interface between elements that interact through such ports." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectionDefinition . - -oslc_sysml:InterfaceUsage a rdfs:Class ; - rdfs:label "InterfaceUsage" ; - rdfs:comment "An InterfaceUsage is a Usage of an InterfaceDefinition to represent an interface connecting parts of a system through specific ports." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectionUsage . - -oslc_sysml:Intersecting a rdfs:Class ; - rdfs:label "Intersecting" ; - rdfs:comment "Intersecting is a Relationship that makes its intersectingType one of the intersectingTypes of its typeIntersected." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:Invariant a rdfs:Class ; - rdfs:label "Invariant" ; - rdfs:comment "An Invariant is a BooleanExpression that is asserted to have a specific Boolean result value. If isNegated = false, then the result is asserted to be true. If isNegated = true, then the result is asserted to be false." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:BooleanExpression . - -oslc_sysml:InvocationExpression a rdfs:Class ; - rdfs:label "InvocationExpression" ; - rdfs:comment "An InvocationExpression is an Expression each of whose input parameters are bound to the result of an argument Expression." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:ItemDefinition a rdfs:Class ; - rdfs:label "ItemDefinition" ; - rdfs:comment "An ItemDefinition is an OccurrenceDefinition of the Structure of things that may themselves be systems or parts of systems, but may also be things that are acted on by a system or parts of a system, but which do not necessarily perform actions themselves. This includes items that can be exchanged between parts of a system, such as water or electrical signals." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceDefinition, - oslc_sysml:Structure . - -oslc_sysml:ItemFeature a rdfs:Class ; - rdfs:label "ItemFeature" ; - rdfs:comment "An ItemFeature is the ownedFeature of an ItemFlow that identifies the things carried by the kinds of transfers that are instances of the ItemFlow." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature . - -oslc_sysml:ItemFlow a rdfs:Class ; - rdfs:label "ItemFlow" ; - rdfs:comment "An ItemFlow is a Step that represents the transfer of objects or data values from one Feature to another. ItemFlows can take non-zero time to complete." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Connector, - oslc_sysml:Step . - -oslc_sysml:ItemFlowEnd a rdfs:Class ; - rdfs:label "ItemFlowEnd" ; - rdfs:comment "An ItemFlowEnd is a Feature that is one of the connectorEnds giving the source or target of an ItemFlow. For ItemFlows typed by FlowTransfer or its specializations, ItemFlowEnds must have exactly one ownedFeature, which redefines Transfer::source::sourceOutput or Transfer::target::targetInput and redefines the corresponding feature of the relatedElement for its end." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature . - -oslc_sysml:ItemUsage a rdfs:Class ; - rdfs:label "ItemUsage" ; - rdfs:comment "An ItemUsage is a ItemUsage whose definition is a Structure. Nominally, if the definition is an ItemDefinition, an ItemUsage is a ItemUsage of that ItemDefinition within a system. However, other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceUsage . - -oslc_sysml:JoinNode a rdfs:Class ; - rdfs:label "JoinNode" ; - rdfs:comment "A JoinNode is a ControlNode that waits for the completion of all the predecessor Actions given by incoming Successions." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ControlNode . - -oslc_sysml:LibraryPackage a rdfs:Class ; - rdfs:label "LibraryPackage" ; - rdfs:comment "A LibraryPackage is a Package that is the container for a model library. A LibraryPackage is itself a library Element as are all Elements that are directly or indirectly contained in it." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Package . - -oslc_sysml:LifeClass a rdfs:Class ; - rdfs:label "LifeClass" ; - rdfs:comment "A LifeClass is a Class that specializes both the Class Occurrences::Life from the Kernel Semantic Library and a single OccurrenceDefinition, and has a multiplicity of 0..1. This constrains the OccurrenceDefinition being specialized to have at most one instance that is a complete Life." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Class . - -oslc_sysml:LiteralBoolean a rdfs:Class ; - rdfs:label "LiteralBoolean" ; - rdfs:comment "LiteralBoolean is a LiteralExpression that provides a Boolean value as a result. Its result parameter must have type Boolean." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LiteralExpression . - -oslc_sysml:LiteralExpression a rdfs:Class ; - rdfs:label "LiteralExpression" ; - rdfs:comment "A LiteralExpression is an Expression that provides a basic DataValue as a result." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:LiteralInfinity a rdfs:Class ; - rdfs:label "LiteralInfinity" ; - rdfs:comment "A LiteralInfinity is a LiteralExpression that provides the positive infinity value (*). It's result must have the type Positive." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LiteralExpression . - -oslc_sysml:LiteralInteger a rdfs:Class ; - rdfs:label "LiteralInteger" ; - rdfs:comment "A LiteralInteger is a LiteralExpression that provides an Integer value as a result. Its result parameter must have the type Integer." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LiteralExpression . - -oslc_sysml:LiteralRational a rdfs:Class ; - rdfs:label "LiteralRational" ; - rdfs:comment "A LiteralRational is a LiteralExpression that provides a Rational value as a result. Its result parameter must have the type Rational." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LiteralExpression . - -oslc_sysml:LiteralString a rdfs:Class ; - rdfs:label "LiteralString" ; - rdfs:comment "A LiteralString is a LiteralExpression that provides a String value as a result. Its result parameter must have the type String." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LiteralExpression . - -oslc_sysml:LoopActionUsage a rdfs:Class ; - rdfs:label "LoopActionUsage" ; - rdfs:comment "A LoopActionUsage is an ActionUsage that specifies that its bodyAction should be performed repeatedly. Its subclasses WhileLoopActionUsage and ForLoopActionUsage provide different ways to determine how many times the bodyAction should be performed." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:Membership a rdfs:Class ; - rdfs:label "Membership" ; - rdfs:comment "A Membership is a Relationship between a Namespace and an Element that indicates the Element is a member of (i.e., is contained in) the Namespace. Any memberNames specify how the memberElement is identified in the Namespace and the visibility specifies whether or not the memberElement is publicly visible from outside the Namespace." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:MembershipExpose a rdfs:Class ; - rdfs:label "MembershipExpose" ; - rdfs:comment "A MembershipExpose is an Expose that exposes a specific importedMembership and, if isRecursive = true, additional Memberships recursively." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expose, - oslc_sysml:MembershipImport . - -oslc_sysml:MembershipImport a rdfs:Class ; - rdfs:label "MembershipImport" ; - rdfs:comment "A MembershipImport is an Import that imports its importedMembership into the importOwningNamespace. If isRecursive = true and the memberElement of the importedMembership is a Namespace, then the equivalent of a recursive NamespaceImport is also performed on that Namespace." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Import . - -oslc_sysml:MergeNode a rdfs:Class ; - rdfs:label "MergeNode" ; - rdfs:comment "A MergeNode is a ControlNode that asserts the merging of its incoming Successions. A MergeNode may have at most one outgoing Successions." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ControlNode . - -oslc_sysml:Metaclass a rdfs:Class ; - rdfs:label "Metaclass" ; - rdfs:comment "A Metaclass is a Structure used to type MetadataFeatures." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Structure . - -oslc_sysml:MetadataAccessExpression a rdfs:Class ; - rdfs:label "MetadataAccessExpression" ; - rdfs:comment "A MetadataAccessExpression is an Expression whose result is a sequence of instances of Metaclasses representing all the MetadataFeature annotations of the referencedElement. In addition, the sequence includes an instance of the reflective Metaclass corresponding to the MOF class of the referencedElement, with values for all the abstract syntax properties of the referencedElement." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:MetadataDefinition a rdfs:Class ; - rdfs:label "MetadataDefinition" ; - rdfs:comment "A MetadataDefinition is an ItemDefinition that is also a Metaclass." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ItemDefinition, - oslc_sysml:Metaclass . - -oslc_sysml:MetadataFeature a rdfs:Class ; - rdfs:label "MetadataFeature" ; - rdfs:comment "A MetadataFeature is a Feature that is an AnnotatingElement used to annotate another Element with metadata. It is typed by a Metaclass. All its ownedFeatures must redefine features of its metaclass and any feature bindings must be model-level evaluable." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AnnotatingElement, - oslc_sysml:Feature . - -oslc_sysml:MetadataUsage a rdfs:Class ; - rdfs:label "MetadataUsage" ; - rdfs:comment "A MetadataUsage is a Usage and a MetadataFeature, used to annotate other Elements in a system model with metadata. As a MetadataFeature, its type must be a Metaclass, which will nominally be a MetadataDefinition. However, any kernel Metaclass is also allowed, to permit use of Metaclasses from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ItemUsage, - oslc_sysml:MetadataFeature . - -oslc_sysml:Multiplicity a rdfs:Class ; - rdfs:label "Multiplicity" ; - rdfs:comment """A Multiplicity is a Feature whose co-domain is a set of natural numbers giving the allowed cardinalities of each typeWithMultiplicity. The cardinality of a Type is defined as follows, depending on whether the Type is a Classifier or Feature. -.""" ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature . - -oslc_sysml:MultiplicityRange a rdfs:Class ; - rdfs:label "MultiplicityRange" ; - rdfs:comment "A MultiplicityRange is a Multiplicity whose value is defined to be the (inclusive) range of natural numbers given by the result of a lowerBound Expression and the result of an upperBound Expression. The result of these Expressions shall be of type Natural. If the result of the upperBound Expression is the unbounded value *, then the specified range includes all natural numbers greater than or equal to the lowerBound value. If no lowerBound Expression, then the default is that the lower bound has the same value as the upper bound, except if the upperBound evaluates to *, in which case the default for the lower bound is 0." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Multiplicity . - -oslc_sysml:Namespace a rdfs:Class ; - rdfs:label "Namespace" ; - rdfs:comment "A Namespace is an Element that contains other Elements, known as its members, via Membership Relationships with those Elements. The members of a Namespace may be owned by the Namespace, aliased in the Namespace, or imported into the Namespace via Import Relationships." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Element . - -oslc_sysml:NamespaceExpose a rdfs:Class ; - rdfs:label "NamespaceExpose" ; - rdfs:comment "A NamespaceExpose is an Expose Relationship that exposes the Memberships of a specific importedNamespace and, if isRecursive = true, additional Memberships recursively." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expose, - oslc_sysml:NamespaceImport . - -oslc_sysml:NamespaceImport a rdfs:Class ; - rdfs:label "NamespaceImport" ; - rdfs:comment "A NamespaceImport is an Import that imports Memberships from its importedNamespace into the importOwningNamespace. If isRecursive = false, then only the visible Memberships of the importedNamespace are imported. If isRecursive = true, then, in addition, Memberships are recursively imported from any ownedMembers of the importedNamespace that are Namespaces." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Import . - -oslc_sysml:NullExpression a rdfs:Class ; - rdfs:label "NullExpression" ; - rdfs:comment "A NullExpression is an Expression that results in a null value." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Expression . - -oslc_sysml:ObjectiveMembership a rdfs:Class ; - rdfs:label "ObjectiveMembership" ; - rdfs:comment "An ObjectiveMembership is a FeatureMembership that indicates that its ownedObjectiveRequirement is the objective RequirementUsage for its owningType, which must be a CaseDefinition or CaseUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:OccurrenceDefinition a rdfs:Class ; - rdfs:label "OccurrenceDefinition" ; - rdfs:comment "An OccurrenceDefinition is a Definition of a Class of individuals that have an independent life over time and potentially an extent over space. This includes both structural things and behaviors that act on such structures." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Class, - oslc_sysml:Definition . - -oslc_sysml:OccurrenceUsage a rdfs:Class ; - rdfs:label "OccurrenceUsage" ; - rdfs:comment "An OccurrenceUsage is a Usage whose types are all Classes. Nominally, if a type is an OccurrenceDefinition, an OccurrenceUsage is a Usage of that OccurrenceDefinition within a system. However, other types of Kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Usage . - -oslc_sysml:OperatorExpression a rdfs:Class ; - rdfs:label "OperatorExpression" ; - rdfs:comment "An OperatorExpression is an InvocationExpression whose function is determined by resolving its operator in the context of one of the standard packages from the Kernel Function Library." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:InvocationExpression . - -oslc_sysml:OwningMembership a rdfs:Class ; - rdfs:label "OwningMembership" ; - rdfs:comment "An OwningMembership is a Membership that owns its memberElement as a ownedRelatedElement. The ownedMemberElement becomes an ownedMember of the membershipOwningNamespace." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Membership . - -oslc_sysml:Package a rdfs:Class ; - rdfs:label "Package" ; - rdfs:comment "A Package is a Namespace used to group Elements, without any instance-level semantics. It may have one or more model-level evaluable filterCondition Expressions used to filter its importedMemberships. Any imported member must meet all of the filterConditions." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Namespace . - -oslc_sysml:ParameterMembership a rdfs:Class ; - rdfs:label "ParameterMembership" ; - rdfs:comment "A ParameterMembership is a FeatureMembership that identifies its memberFeature as a parameter, which is always owned, and must have a direction. A ParameterMembership must be owned by a Behavior or a Step." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:PartDefinition a rdfs:Class ; - rdfs:label "PartDefinition" ; - rdfs:comment "A PartDefinition is an ItemDefinition of a Class of systems or parts of systems. Note that all parts may be considered items for certain purposes, but not all items are parts that can perform actions within a system." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ItemDefinition . - -oslc_sysml:PartUsage a rdfs:Class ; - rdfs:label "PartUsage" ; - rdfs:comment "A PartUsage is a usage of a PartDefinition to represent a system or a part of a system. At least one of the itemDefinitions of the PartUsage must be a PartDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ItemUsage . - -oslc_sysml:PerformActionUsage a rdfs:Class ; - rdfs:label "PerformActionUsage" ; - rdfs:comment "A PerformActionUsage is an ActionUsage that represents the performance of an ActionUsage. Unless it is the PerformActionUsage itself, the ActionUsage to be performed is related to the PerformActionUsage by a ReferenceSubsetting relationship. A PerformActionUsage is also an EventOccurrenceUsage, with its performedAction as the eventOccurrence." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage, - oslc_sysml:EventOccurrenceUsage . - -oslc_sysml:PortConjugation a rdfs:Class ; - rdfs:label "PortConjugation" ; - rdfs:comment "A PortConjugation is a Conjugation Relationship between a PortDefinition and its corresponding ConjugatedPortDefinition. As a result of this Relationship, the ConjugatedPortDefinition inherits all the features of the original PortDefinition, but input flows of the original PortDefinition become outputs on the ConjugatedPortDefinition and output flows of the original PortDefinition become inputs on the ConjugatedPortDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Conjugation . - -oslc_sysml:PortDefinition a rdfs:Class ; - rdfs:label "PortDefinition" ; - rdfs:comment "A PortDefinition defines a point at which external entities can connect to and interact with a system or part of a system. Any ownedUsages of a PortDefinition, other than PortUsages, must not be composite." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceDefinition, - oslc_sysml:Structure . - -oslc_sysml:PortUsage a rdfs:Class ; - rdfs:label "PortUsage" ; - rdfs:comment "A PortUsage is a usage of a PortDefinition. A PortUsage itself as well as all its nestedUsages must be referential (non-composite)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OccurrenceUsage . - -oslc_sysml:PortionKind a rdfs:Class ; - rdfs:label "PortionKind" ; - rdfs:comment "PortionKind is an enumeration of the specific kinds of Occurrence portions that can be represented by an OccurrenceUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:Predicate a rdfs:Class ; - rdfs:label "Predicate" ; - rdfs:comment "A Predicate is a Function whose result parameter has type Boolean and multiplicity 1..1." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Function . - -oslc_sysml:Redefinition a rdfs:Class ; - rdfs:label "Redefinition" ; - rdfs:comment "Redefinition is a kind of Subsetting that requires the redefinedFeature and the redefiningFeature to have the same values (on each instance of the domain of the redefiningFeature). This means any restrictions on the redefiningFeature, such as type or multiplicity, also apply to the redefinedFeature (on each instance of the domain of the redefiningFeature), and vice versa. The redefinedFeature might have values for instances of the domain of the redefiningFeature, but only as instances of the domain of the redefinedFeature that happen to also be instances of the domain of the redefiningFeature. This is supported by the constraints inherited from Subsetting on the domains of the redefiningFeature and redefinedFeature. However, these constraints are narrowed for Redefinition to require the owningTypes of the redefiningFeature and redefinedFeature to be different and the redefinedFeature to not be inherited into the owningNamespace of the redefiningFeature.This enables the redefiningFeature to have the same name as the redefinedFeature, if desired." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Subsetting . - -oslc_sysml:ReferenceSubsetting a rdfs:Class ; - rdfs:label "ReferenceSubsetting" ; - rdfs:comment "ReferenceSubsetting is a kind of Subsetting in which the referencedFeature is syntactically distinguished from other Features subsetted by the referencingFeature. ReferenceSubsetting has the same semantics as Subsetting, but the referenceFeature may have a special purpose relative to the referencingFeature. For instance, ReferenceSubsetting is used to identify the relatedFeatures of a Connector." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Subsetting . - -oslc_sysml:ReferenceUsage a rdfs:Class ; - rdfs:label "ReferenceUsage" ; - rdfs:comment "A ReferenceUsage is a Usage that specifies a non-compositional (isComposite = false) reference to something. The definition of a ReferenceUsage can be any kind of Classifier, with the default being the top-level Classifier Base::Anything from the Kernel Semantic Library. This allows the specification of a generic reference without distinguishing if the thing referenced is an attribute value, item, action, etc." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Usage . - -oslc_sysml:Relationship a rdfs:Class ; - rdfs:label "Relationship" ; - rdfs:comment "A Relationship is an Element that relates other Element. Some of its relatedElements may be owned, in which case those ownedRelatedElements will be deleted from a model if their owningRelationship is. A Relationship may also be owned by another Element, in which case the ownedRelatedElements of the Relationship are also considered to be transitively owned by the owningRelatedElement of the Relationship." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Element . - -oslc_sysml:RenderingDefinition a rdfs:Class ; - rdfs:label "RenderingDefinition" ; - rdfs:comment "A RenderingDefinition is a PartDefinition that defines a specific rendering of the content of a model view (e.g., symbols, style, layout, etc.)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PartDefinition . - -oslc_sysml:RenderingUsage a rdfs:Class ; - rdfs:label "RenderingUsage" ; - rdfs:comment "A RenderingUsage is the usage of a RenderingDefinition to specify the rendering of a specific model view to produce a physical view artifact." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PartUsage . - -oslc_sysml:RequirementConstraintKind a rdfs:Class ; - rdfs:label "RequirementConstraintKind" ; - rdfs:comment "A RequirementConstraintKind indicates whether a ConstraintUsage is an assumption or a requirement in a RequirementDefinition or RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:RequirementConstraintMembership a rdfs:Class ; - rdfs:label "RequirementConstraintMembership" ; - rdfs:comment "A RequirementConstraintMembership is a FeatureMembership for an assumed or required ConstraintUsage of a RequirementDefinition or RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:RequirementDefinition a rdfs:Class ; - rdfs:label "RequirementDefinition" ; - rdfs:comment "A RequirementDefinition is a ConstraintDefinition that defines a requirement used in the context of a specification as a constraint that a valid solution must satisfy. The specification is relative to a specified subject, possibly in collaboration with one or more external actors." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConstraintDefinition . - -oslc_sysml:RequirementUsage a rdfs:Class ; - rdfs:label "RequirementUsage" ; - rdfs:comment "A RequirementUsage is a Usage of a RequirementDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConstraintUsage . - -oslc_sysml:RequirementVerificationMembership a rdfs:Class ; - rdfs:label "RequirementVerificationMembership" ; - rdfs:comment "A RequirementVerificationMembership is a RequirementConstraintMembership used in the objective of a VerificationCase to identify a RequirementUsage that is verified by the VerificationCase." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementConstraintMembership . - -oslc_sysml:ResultExpressionMembership a rdfs:Class ; - rdfs:label "ResultExpressionMembership" ; - rdfs:comment "A ResultExpressionMembership is a FeatureMembership that indicates that the ownedResultExpression provides the result values for the Function or Expression that owns it. The owning Function or Expression must contain a BindingConnector between the result parameter of the ownedResultExpression and the result parameter of the owning Function or Expression." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:ReturnParameterMembership a rdfs:Class ; - rdfs:label "ReturnParameterMembership" ; - rdfs:comment "A ReturnParameterMembership is a ParameterMembership that indicates that the ownedMemberParameter is the result parameter of a Function or Expression. The direction of the ownedMemberParameter must be out." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ParameterMembership . - -oslc_sysml:SatisfyRequirementUsage a rdfs:Class ; - rdfs:label "SatisfyRequirementUsage" ; - rdfs:comment "A SatisfyRequirementUsage is an AssertConstraintUsage that asserts, by default, that a satisfied RequirementUsage is true for a specific satisfyingFeature, or, if isNegated = true, that the RequirementUsage is false. The satisfied RequirementUsage is related to the SatisfyRequirementUsage by a ReferenceSubsetting Relationship." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AssertConstraintUsage, - oslc_sysml:RequirementUsage . - -oslc_sysml:SelectExpression a rdfs:Class ; - rdfs:label "SelectExpression" ; - rdfs:comment "A SelectExpression is an OperatorExpression whose operator is \"select\", which resolves to the Function ControlFunctions::select from the Kernel Functions Library." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OperatorExpression . - -oslc_sysml:SendActionUsage a rdfs:Class ; - rdfs:label "SendActionUsage" ; - rdfs:comment "A SendActionUsage is an ActionUsage that specifies the sending of a payload given by the result of its payloadArgument Expression via a MessageTransfer whose source is given by the result of the senderArgument Expression and whose target is given by the result of the receiverArgument Expression. If no senderArgument is provided, the default is the this context for the action. If no receiverArgument is given, then the receiver is to be determined by, e.g., outgoing Connections from the sender." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:Specialization a rdfs:Class ; - rdfs:label "Specialization" ; - rdfs:comment "Specialization is a Relationship between two Types that requires all instances of the specific type to also be instances of the general Type (i.e., the set of instances of the specific Type is a subset of those of the general Type, which might be the same set)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:StakeholderMembership a rdfs:Class ; - rdfs:label "StakeholderMembership" ; - rdfs:comment "A StakeholderMembership is a ParameterMembership that identifies a PartUsage as a stakeholderParameter of a RequirementDefinition or RequirementUsage, which specifies a role played by an entity with concerns framed by the owningType." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ParameterMembership . - -oslc_sysml:StateDefinition a rdfs:Class ; - rdfs:label "StateDefinition" ; - rdfs:comment "A StateDefinition is the Definition of the Behavior of a system or part of a system in a certain state condition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionDefinition . - -oslc_sysml:StateSubactionKind a rdfs:Class ; - rdfs:label "StateSubactionKind" ; - rdfs:comment "A StateSubactionKind indicates whether the action of a StateSubactionMembership is an entry, do or exit action." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:StateSubactionMembership a rdfs:Class ; - rdfs:label "StateSubactionMembership" ; - rdfs:comment "A StateSubactionMembership is a FeatureMembership for an entry, do or exit ActionUsage of a StateDefinition or StateUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:StateUsage a rdfs:Class ; - rdfs:label "StateUsage" ; - rdfs:comment """A StateUsage is an ActionUsage that is nominally the Usage of a StateDefinition. However, other kinds of kernel Behaviors are also allowed as types, to permit use of Behaviors -.""" ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:Step a rdfs:Class ; - rdfs:label "Step" ; - rdfs:comment "A Step is a Feature that is typed by one or more Behaviors. Steps may be used by one Behavior to coordinate the performance of other Behaviors, supporting a steady refinement of behavioral descriptions. Steps can be ordered in time and can be connected using ItemFlows to specify things flowing between their parameters." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature . - -oslc_sysml:Structure a rdfs:Class ; - rdfs:label "Structure" ; - rdfs:comment "A Structure is a Class of objects in the modeled universe that are primarily structural in nature. While such an object is not itself behavioral, it may be involved in and acted on by Behaviors, and it may be the performer of some of them." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Class . - -oslc_sysml:Subclassification a rdfs:Class ; - rdfs:label "Subclassification" ; - rdfs:comment "Subclassification is Specialization in which both the specific and general Types are Classifier. This means all instances of the specific Classifier are also instances of the general Classifier." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Specialization . - -oslc_sysml:SubjectMembership a rdfs:Class ; - rdfs:label "SubjectMembership" ; - rdfs:comment "A SubjectMembership is a ParameterMembership that indicates that its ownedSubjectParameter is the subject of its owningType. The owningType of a SubjectMembership must be a RequirementDefinition, RequirementUsage, CaseDefinition, or CaseUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ParameterMembership . - -oslc_sysml:Subsetting a rdfs:Class ; - rdfs:label "Subsetting" ; - rdfs:comment "Subsetting is Specialization in which the specific and general Types are Features. This means all values of the subsettingFeature (on instances of its domain, i.e., the intersection of its featuringTypes) are values of the subsettedFeature on instances of its domain. To support this the domain of the subsettingFeature must be the same or specialize (at least indirectly) the domain of the subsettedFeature (via Specialization), and the co-domain (intersection of the types) of the subsettingFeature must specialize the co-domain of the subsettedFeature." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Specialization . - -oslc_sysml:Succession a rdfs:Class ; - rdfs:label "Succession" ; - rdfs:comment "A Succession is a binary Connector that requires its relatedFeatures to happen separately in time." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Connector . - -oslc_sysml:SuccessionAsUsage a rdfs:Class ; - rdfs:label "SuccessionAsUsage" ; - rdfs:comment "A SuccessionAsUsage is both a ConnectorAsUsage and a Succession." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ConnectorAsUsage, - oslc_sysml:Succession . - -oslc_sysml:SuccessionFlowConnectionUsage a rdfs:Class ; - rdfs:label "SuccessionFlowConnectionUsage" ; - rdfs:comment "A SuccessionFlowConnectionUsage is a FlowConnectionUsage that is also a SuccessionItemFlow." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FlowConnectionUsage, - oslc_sysml:SuccessionItemFlow . - -oslc_sysml:SuccessionItemFlow a rdfs:Class ; - rdfs:label "SuccessionItemFlow" ; - rdfs:comment "A SuccessionItemFlow is an ItemFlow that also provides temporal ordering. It classifies Transfers that cannot start until the source Occurrence has completed and that must complete before the target Occurrence can start." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ItemFlow, - oslc_sysml:Succession . - -oslc_sysml:TerminateActionUsage a rdfs:Class ; - rdfs:label "TerminateActionUsage" ; - rdfs:comment "A TerminateActionUsage is an ActionUsage that directly or indirectly specializes the ActionDefinition TerminateAction from the Systems Model Library, which causes a given terminatedOccurrence to end during its performance. By default, the terminatedOccurrence is the featuring instance (that) of the performance of the TerminateActionUsage, generally the performance of its immediately containing ActionDefinition or ActionUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:TextualRepresentation a rdfs:Class ; - rdfs:label "TextualRepresentation" ; - rdfs:comment "A TextualRepresentation is an AnnotatingElement whose body represents the representedElement in a given language. The representedElement must be the owner of the TextualRepresentation. The named language can be a natural language, in which case the body is an informal representation, or an artificial language, in which case the body is expected to be a formal, machine-parsable representation." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:AnnotatingElement . - -oslc_sysml:TransitionFeatureKind a rdfs:Class ; - rdfs:label "TransitionFeatureKind" ; - rdfs:comment "A TransitionActionKind indicates whether the transitionFeature of a TransitionFeatureMembership is a trigger, guard or effect." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:TransitionFeatureMembership a rdfs:Class ; - rdfs:label "TransitionFeatureMembership" ; - rdfs:comment "A TransitionFeatureMembership is a FeatureMembership for a trigger, guard or effect of a TransitionUsage, whose transitionFeature is a AcceptActionUsage, Boolean-valued Expression or ActionUsage, depending on its kind. ." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:TransitionUsage a rdfs:Class ; - rdfs:label "TransitionUsage" ; - rdfs:comment "A TransitionUsage is an ActionUsage representing a triggered transition between ActionUsages or StateUsages. When triggered by a triggerAction, when its guardExpression is true, the TransitionUsage asserts that its source is exited, then its effectAction (if any) is performed, and then its target is entered." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:ActionUsage . - -oslc_sysml:TriggerInvocationExpression a rdfs:Class ; - rdfs:label "TriggerInvocationExpression" ; - rdfs:comment "A TriggerInvocationExpression is an InvocationExpression that invokes one of the trigger Functions from the Kernel Semantic Library Triggers package, as indicated by its kind." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:InvocationExpression . - -oslc_sysml:TriggerKind a rdfs:Class ; - rdfs:label "TriggerKind" ; - rdfs:comment "TriggerKind enumerates the kinds of triggers that can be represented by a TriggerInvocationExpression." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:Type a rdfs:Class ; - rdfs:label "Type" ; - rdfs:comment "A Type is a Namespace that is the most general kind of Element supporting the semantics of classification. A Type may be a Classifier or a Feature, defining conditions on what is classified by the Type (see also the description of isSufficient)." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Namespace . - -oslc_sysml:TypeFeaturing a rdfs:Class ; - rdfs:label "TypeFeaturing" ; - rdfs:comment "A TypeFeaturing is a Featuring Relationship in which the featureOfType is the source and the featuringType is the target." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Featuring . - -oslc_sysml:Unioning a rdfs:Class ; - rdfs:label "Unioning" ; - rdfs:comment "Unioning is a Relationship that makes its unioningType one of the unioningTypes of its typeUnioned." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Relationship . - -oslc_sysml:Usage a rdfs:Class ; - rdfs:label "Usage" ; - rdfs:comment "A Usage is a usage of a Definition. A Usage may only be an ownedFeature of a Definition or another Usage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:Feature . - -oslc_sysml:UseCaseDefinition a rdfs:Class ; - rdfs:label "UseCaseDefinition" ; - rdfs:comment "A UseCaseDefinition is a CaseDefinition that specifies a set of actions performed by its subject, in interaction with one or more actors external to the subject. The objective is to yield an observable result that is of value to one or more of the actors." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseDefinition . - -oslc_sysml:UseCaseUsage a rdfs:Class ; - rdfs:label "UseCaseUsage" ; - rdfs:comment "A UseCaseUsage is a Usage of a UseCaseDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseUsage . - -oslc_sysml:VariantMembership a rdfs:Class ; - rdfs:label "VariantMembership" ; - rdfs:comment "A VariantMembership is a Membership between a variation point Definition or Usage and a Usage that represents a variant in the context of that variation. The membershipOwningNamespace for the VariantMembership must be either a Definition or a Usage with isVariation = true." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:OwningMembership . - -oslc_sysml:VerificationCaseDefinition a rdfs:Class ; - rdfs:label "VerificationCaseDefinition" ; - rdfs:comment "A VerificationCaseDefinition is a CaseDefinition for the purpose of verification of the subject of the case against its requirements." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseDefinition . - -oslc_sysml:VerificationCaseUsage a rdfs:Class ; - rdfs:label "VerificationCaseUsage" ; - rdfs:comment "A VerificationCaseUsage is a Usage of a VerificationCaseDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:CaseUsage . - -oslc_sysml:ViewDefinition a rdfs:Class ; - rdfs:label "ViewDefinition" ; - rdfs:comment "A ViewDefinition is a PartDefinition that specifies how a view artifact is constructed to satisfy a viewpoint. It specifies a viewConditions to define the model content to be presented and a viewRendering to define how the model content is presented." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PartDefinition . - -oslc_sysml:ViewRenderingMembership a rdfs:Class ; - rdfs:label "ViewRenderingMembership" ; - rdfs:comment "A ViewRenderingMembership is a FeatureMembership that identifies the viewRendering of a ViewDefinition or ViewUsage." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:FeatureMembership . - -oslc_sysml:ViewUsage a rdfs:Class ; - rdfs:label "ViewUsage" ; - rdfs:comment "A ViewUsage is a usage of a ViewDefinition to specify the generation of a view of the members of a collection of exposedNamespaces. The ViewUsage can satisfy more viewpoints than its definition, and it can specialize the viewRendering specified by its definition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:PartUsage . - -oslc_sysml:ViewpointDefinition a rdfs:Class ; - rdfs:label "ViewpointDefinition" ; - rdfs:comment "A ViewpointDefinition is a RequirementDefinition that specifies one or more stakeholder concerns that are to be satisfied by creating a view of a model." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementDefinition . - -oslc_sysml:ViewpointUsage a rdfs:Class ; - rdfs:label "ViewpointUsage" ; - rdfs:comment "A ViewpointUsage is a Usage of a ViewpointDefinition." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:RequirementUsage . - -oslc_sysml:VisibilityKind a rdfs:Class ; - rdfs:label "VisibilityKind" ; - rdfs:comment "VisibilityKind is an enumeration whose literals specify the visibility of a Membership of an Element in a Namespace outside of that Namespace. Note that \"visibility\" specifically restricts whether an Element in a Namespace may be referenced by name from outside the Namespace and only otherwise restricts access to an Element as provided by specific constraints in the abstract syntax (e.g., preventing the import or inheritance of private Elements)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:WhileLoopActionUsage a rdfs:Class ; - rdfs:label "WhileLoopActionUsage" ; - rdfs:comment "A WhileLoopActionUsage is a LoopActionUsage that specifies that the bodyAction ActionUsage should be performed repeatedly while the result of the whileArgument Expression is true or until the result of the untilArgument Expression (if provided) is true. The whileArgument Expression is evaluated before each (possible) performance of the bodyAction, and the untilArgument Expression is evaluated after each performance of the bodyAction." ; - rdfs:isDefinedBy oslc_sysml: ; - rdfs:subClassOf oslc_sysml:LoopActionUsage . - -oslc_sysml:action a rdf:Property ; - rdfs:label "action" ; - rdfs:comment """ActionDefinition: The ActionUsages that are steps in this ActionDefinition, which define the actions that specify the behavior of the ActionDefinition. -StateSubactionMembership: The ActionUsage that is the ownedMemberFeature of this StateSubactionMembership.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:actionDefinition a rdf:Property ; - rdfs:label "actionDefinition" ; - rdfs:comment "ActionUsage: The Behaviors that are the types of this ActionUsage. Nominally, these would be ActionDefinitions, but other kinds of Kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:actorParameter a rdf:Property ; - rdfs:label "actorParameter" ; - rdfs:comment """RequirementUsage: The parameters of this RequirementUsage that represent actors involved in the requirement. -RequirementDefinition: The parameters of this RequirementDefinition that represent actors involved in the requirement. -CaseUsage: The parameters of this CaseUsage that represent actors involved in the case. -CaseDefinition: The parameters of this CaseDefinition that represent actors involved in the case.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:after a oslc_sysml:TriggerKind ; - rdfs:label "after" ; - rdfs:comment "Indicates a relative time trigger, corresponding to the TriggerAfter Function from the Triggers model in the Kernel Semantic Library." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:aliasIds a rdf:Property ; - rdfs:label "aliasIds" ; - rdfs:comment "Element: Various alternative identifiers for this Element. Generally, these will be set by tools." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:allocation a rdf:Property ; - rdfs:label "allocation" ; - rdfs:comment "AllocationDefinition: The AllocationUsages that refine the allocation mapping defined by this AllocationDefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:allocationDefinition a rdf:Property ; - rdfs:label "allocationDefinition" ; - rdfs:comment "AllocationUsage: The AllocationDefinitions that are the types of this AllocationUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:analysisCaseDefinition a rdf:Property ; - rdfs:label "analysisCaseDefinition" ; - rdfs:comment "AnalysisCaseUsage: The AnalysisCaseDefinition that is the definition of this AnalysisCaseUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:annotatedElement a rdf:Property ; - rdfs:label "annotatedElement" ; - rdfs:comment """AnnotatingElement: The Elements that are annotated by this AnnotatingElement. If annotation is not empty, these are the annotatedElements of the annotations. If annotation is empty, then it is the owningNamespace of the AnnotatingElement. -Annotation: The Element that is annotated by the annotatingElement of this Annotation.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:annotatingElement a rdf:Property ; - rdfs:label "annotatingElement" ; - rdfs:comment "Annotation: The AnnotatingElement that annotates the annotatedElement of this Annotation." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:annotation a rdf:Property ; - rdfs:label "annotation" ; - rdfs:comment "AnnotatingElement: The Annotations that relate this AnnotatingElement to its annotatedElements." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:argument a rdf:Property ; - rdfs:label "argument" ; - rdfs:comment "InvocationExpression: The value Expressions of the FeatureValues of the owned input parameters of the InvocationExpression." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:assertedConstraint a rdf:Property ; - rdfs:label "assertedConstraint" ; - rdfs:comment "AssertConstraintUsage: The ConstraintUsage to be performed by the AssertConstraintUsage. It is the referenceFeature of the ownedReferenceSubsetting for the AssertConstraintUsage, if there is one, and, otherwise, the AssertConstraintUsage itself." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:association a rdf:Property ; - rdfs:label "association" ; - rdfs:comment "Connector: The Associations that type the Connector." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:associationEnd a rdf:Property ; - rdfs:label "associationEnd" ; - rdfs:comment "Association: The features of the Association that identify the things that can be related by it. A concrete Association must have at least two associationEnds. When it has exactly two, the Association is called a binary Association." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:assumedConstraint a rdf:Property ; - rdfs:label "assumedConstraint" ; - rdfs:comment """RequirementUsage: The owned ConstraintUsages that represent assumptions of this RequirementUsage, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = assumption. -RequirementDefinition: The owned ConstraintUsages that represent assumptions of this RequirementDefinition, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = assumption.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:assumption a oslc_sysml:RequirementConstraintKind ; - rdfs:label "assumption" ; - rdfs:comment "Indicates that a member ConstraintUsage of a RequirementDefinition or RequirementUsage represents an assumption." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:at a oslc_sysml:TriggerKind ; - rdfs:label "at" ; - rdfs:comment "Indicates an absolute time trigger, corresponding to the TriggerAt Function from the Triggers model in the Kernel Semantic Library." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:attributeDefinition a rdf:Property ; - rdfs:label "attributeDefinition" ; - rdfs:comment "AttributeUsage: The DataTypes that are the types of this AttributeUsage. Nominally, these are AttributeDefinitions, but other kinds of kernel DataTypes are also allowed, to permit use of DataTypes from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:behavior a rdf:Property ; - rdfs:label "behavior" ; - rdfs:comment "Step: The Behaviors that type this Step." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:body a rdf:Property ; - rdfs:label "body" ; - rdfs:comment """Comment: The annotation text for the Comment. -TextualRepresentation: The textual representation of the representedElement in the given language.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:bodyAction a rdf:Property ; - rdfs:label "bodyAction" ; - rdfs:comment "LoopActionUsage: The ActionUsage to be performed repeatedly by the LoopActionUsage. It is the second parameter of the LoopActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:bound a rdf:Property ; - rdfs:label "bound" ; - rdfs:comment "MultiplicityRange: The owned Expressions of the MultiplicityRange whose results provide its bounds. These must be the only ownedMembers of the MultiplicityRange." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:calculation a rdf:Property ; - rdfs:label "calculation" ; - rdfs:comment "CalculationDefinition: The actions of this CalculationDefinition that are CalculationUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:calculationDefinition a rdf:Property ; - rdfs:label "calculationDefinition" ; - rdfs:comment "CalculationUsage: The Function that is the type of this CalculationUsage. Nominally, this would be a CalculationDefinition, but a kernel Function is also allowed, to permit use of Functions from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:caseDefinition a rdf:Property ; - rdfs:label "caseDefinition" ; - rdfs:comment "CaseUsage: The CaseDefinition that is the type of this CaseUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:chainingFeature a rdf:Property ; - rdfs:label "chainingFeature" ; - rdfs:comment """Feature: The Feature that are chained together to determine the values of this Feature, derived from the chainingFeatures of the ownedFeatureChainings of this Feature, in the same order. The values of a Feature with chainingFeatures are the same as values of the last Feature in the chain, which can be found by starting with the values of the first Feature (for each instance of the domain of the original Feature), then using each of those as domain instances to find the values of the second Feature in chainingFeatures, and so on, to values of the last Feature. -FeatureChaining: The Feature whose values partly determine values of featureChained, as described in Feature::chainingFeature.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:client a rdf:Property ; - rdfs:label "client" ; - rdfs:comment "Dependency: The Element or Elements dependent on the supplier Elements." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:concernDefinition a rdf:Property ; - rdfs:label "concernDefinition" ; - rdfs:comment "ConcernUsage: The ConcernDefinition that is the single type of this ConcernUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:condition a rdf:Property ; - rdfs:label "condition" ; - rdfs:comment "ElementFilterMembership: The model-level evaluable Boolean-valued Expression used to filter the imported members of the membershipOwningNamespace of this ElementFilterMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:conjugatedPortDefinition a rdf:Property ; - rdfs:label "conjugatedPortDefinition" ; - rdfs:comment """PortDefinition: The that is conjugate to this PortDefinition. -PortConjugation: The ConjugatedPortDefinition that is conjugate to the originalPortDefinition. -ConjugatedPortTyping: The type of this ConjugatedPortTyping considered as a FeatureTyping, which must be a ConjugatedPortDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:conjugatedType a rdf:Property ; - rdfs:label "conjugatedType" ; - rdfs:comment "Conjugation: The Type that is the result of applying Conjugation to the originalType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:connectionDefinition a rdf:Property ; - rdfs:label "connectionDefinition" ; - rdfs:comment "ConnectionUsage: The AssociationStructures that are the types of this ConnectionUsage. Nominally, these are , but other kinds of Kernel AssociationStructures are also allowed, to permit use of AssociationStructures from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:connectionEnd a rdf:Property ; - rdfs:label "connectionEnd" ; - rdfs:comment "ConnectionDefinition: The Usages that define the things related by the ConnectionDefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:connectorEnd a rdf:Property ; - rdfs:label "connectorEnd" ; - rdfs:comment "Connector: The endFeatures of a Connector, which redefine the endFeatures of the associations of the Connector. The connectorEnds determine via ReferenceSubsetting Relationships which Features are related by the Connector." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:constraintDefinition a rdf:Property ; - rdfs:label "constraintDefinition" ; - rdfs:comment "ConstraintUsage: The (single) Predicate that is the type of this ConstraintUsage. Nominally, this will be a ConstraintDefinition, but other kinds of Predicates are also allowed, to permit use of Predicates from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:declaredName a rdf:Property ; - rdfs:label "declaredName" ; - rdfs:comment "Element: The declared name of this Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:declaredShortName a rdf:Property ; - rdfs:label "declaredShortName" ; - rdfs:comment "Element: An optional alternative name for the Element that is intended to be shorter or in some way more succinct than its primary name. It may act as a modeler-specified identifier for the Element, though it is then the responsibility of the modeler to maintain the uniqueness of this identifier within a model or relative to some other context." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:definition a rdf:Property ; - rdfs:label "definition" ; - rdfs:comment "Usage: The Classifiers that are the types of this Usage. Nominally, these are Definitions, but other kinds of Kernel Classifiers are also allowed, to permit use of Classifiers from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:differencingType a rdf:Property ; - rdfs:label "differencingType" ; - rdfs:comment """Type: The interpretations of a Type with differencingTypes are asserted to be those of the first of those Types, but not including those of the remaining Types. For example, a Classifier might be the difference of a Classifier for people and another for people of a particular nationality, leaving people who are not of that nationality. Similarly, a feature of people might be the difference between a feature for their children and a Classifier for people of a particular sex, identifying their children not of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex). -Differencing: Type that partly determines interpretations of typeDifferenced, as described in Type::differencingType.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:directedFeature a rdf:Property ; - rdfs:label "directedFeature" ; - rdfs:comment "Type: The features of this Type that have a non-null direction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:directedUsage a rdf:Property ; - rdfs:label "directedUsage" ; - rdfs:comment """Usage: The usages of this Usage that are directedFeatures. -Definition: The usages of this Definition that are directedFeatures.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:direction a rdf:Property ; - rdfs:label "direction" ; - rdfs:comment "Feature: Indicates how values of this Feature are determined or used (as specified for the FeatureDirectionKind)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:disjoiningType a rdf:Property ; - rdfs:label "disjoiningType" ; - rdfs:comment "Disjoining: Type asserted to be disjoint with the typeDisjoined." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:do a oslc_sysml:StateSubactionKind ; - rdfs:label "do" ; - rdfs:comment "Indicates that the action of a StateSubactionMembership is a doAction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:doAction a rdf:Property ; - rdfs:label "doAction" ; - rdfs:comment """StateUsage: The ActionUsage of this StateUsage to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = do. -StateDefinition: The ActionUsage of this StateDefinition to be performed while in the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = do.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:documentation a rdf:Property ; - rdfs:label "documentation" ; - rdfs:comment "Element: The Documentation owned by this Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:documentedElement a rdf:Property ; - rdfs:label "documentedElement" ; - rdfs:comment "Documentation: The Element that is documented by this Documentation." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:effect a oslc_sysml:TransitionFeatureKind ; - rdfs:label "effect" ; - rdfs:comment "Indicates that the transitionFeature of a TransitionFeatureMembership is an effectAction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:effectAction a rdf:Property ; - rdfs:label "effectAction" ; - rdfs:comment "TransitionUsage: The ActionUsages that define the effects of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = effect, which must all be ActionUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:effectStep a rdf:Property ; - rdfs:label "effectStep" ; - rdfs:comment "Succession: Steps that represent occurrences that are side effects of the transitionStep occurring." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:elementId a rdf:Property ; - rdfs:label "elementId" ; - rdfs:comment "Element: The globally unique identifier for this Element. This is intended to be set by tooling, and it must not change during the lifetime of the Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:elseAction a rdf:Property ; - rdfs:label "elseAction" ; - rdfs:comment "IfActionUsage: The ActionUsage that is to be performed if the result of the ifArgument is false. It is the (optional) third parameter of the IfActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:endFeature a rdf:Property ; - rdfs:label "endFeature" ; - rdfs:comment "Type: All features of this Type with isEnd = true." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:endOwningType a rdf:Property ; - rdfs:label "endOwningType" ; - rdfs:comment "Feature: The Type that is related to this Feature by an EndFeatureMembership in which the Feature is an ownedMemberFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:entry a oslc_sysml:StateSubactionKind ; - rdfs:label "entry" ; - rdfs:comment "Indicates that the action of a StateSubactionMembership is an entryAction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:entryAction a rdf:Property ; - rdfs:label "entryAction" ; - rdfs:comment """StateUsage: The ActionUsage of this StateUsage to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = entry. -StateDefinition: The ActionUsage of this StateDefinition to be performed on entry to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = entry.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:enumeratedValue a rdf:Property ; - rdfs:label "enumeratedValue" ; - rdfs:comment "EnumerationDefinition: EnumerationUsages of this EnumerationDefinitionthat have distinct, fixed values. Each enumeratedValue specifies one of the allowed instances of the EnumerationDefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:enumerationDefinition a rdf:Property ; - rdfs:label "enumerationDefinition" ; - rdfs:comment "EnumerationUsage: The single EnumerationDefinition that is the type of this EnumerationUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:eventOccurrence a rdf:Property ; - rdfs:label "eventOccurrence" ; - rdfs:comment "EventOccurrenceUsage: The OccurrenceUsage referenced as an event by this EventOccurrenceUsage. It is the referenceFeature of the ownedReferenceSubsetting for the EventOccurrenceUsage, if there is one, and, otherwise, the EventOccurrenceUsage itself." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:exhibitedState a rdf:Property ; - rdfs:label "exhibitedState" ; - rdfs:comment "ExhibitStateUsage: The StateUsage to be exhibited by the ExhibitStateUsage. It is the performedAction of the ExhibitStateUsage considered as a PerformActionUsage, which must be a StateUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:exit a oslc_sysml:StateSubactionKind ; - rdfs:label "exit" ; - rdfs:comment "Indicates that the action of a StateSubactionMembership is an exitAction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:exitAction a rdf:Property ; - rdfs:label "exitAction" ; - rdfs:comment """StateUsage: The ActionUsage of this StateUsage to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateUsage by a StateSubactionMembership with kind = exit. -StateDefinition: The ActionUsage of this StateDefinition to be performed on exit to the state defined by the StateDefinition. It is the owned ActionUsage related to the StateDefinition by a StateSubactionMembership with kind = exit.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:exposedElement a rdf:Property ; - rdfs:label "exposedElement" ; - rdfs:comment "ViewUsage: The Elements that are exposed by this ViewUsage, which are those memberElements of the imported Memberships from all the Expose Relationships that meet all the owned and inherited viewConditions." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:expression a rdf:Property ; - rdfs:label "expression" ; - rdfs:comment "Function: The Expressions that are steps in the calculation of the result of this Function." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:feature a rdf:Property ; - rdfs:label "feature" ; - rdfs:comment """Featuring: The Feature that is featured by the featuringType. -Type: The ownedMemberFeatures of the featureMemberships of this Type.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureChained a rdf:Property ; - rdfs:label "featureChained" ; - rdfs:comment "FeatureChaining: The Feature whose values are partly determined by values of the chainingFeature, as described in Feature::chainingFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureInverted a rdf:Property ; - rdfs:label "featureInverted" ; - rdfs:comment "FeatureInverting: The Feature that is an inverse of the invertingFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureMembership a rdf:Property ; - rdfs:label "featureMembership" ; - rdfs:comment "Type: The FeatureMemberships for features of this Type, which include all ownedFeatureMemberships and those inheritedMemberships that are FeatureMemberships (but does not include any importedMemberships)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureOfType a rdf:Property ; - rdfs:label "featureOfType" ; - rdfs:comment "TypeFeaturing: The Feature that is featured by the featuringType. It is the source of the TypeFeaturing." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureTarget a rdf:Property ; - rdfs:label "featureTarget" ; - rdfs:comment "Feature: The last of the chainingFeatures of this Feature, if it has any. Otherwise, this Feature itself." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featureWithValue a rdf:Property ; - rdfs:label "featureWithValue" ; - rdfs:comment "FeatureValue: The Feature to be provided a value." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:featuringType a rdf:Property ; - rdfs:label "featuringType" ; - rdfs:comment """TypeFeaturing: The Type that features the featureOfType. It is the target of the TypeFeaturing. -Feature: Types that feature this Feature, such that any instance in the domain of the Feature must be classified by all of these Types, including at least all the featuringTypes of its typeFeaturings. If the Feature is chained, then the featuringTypes of the first Feature in the chain are also featuringTypes of the chained Feature.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:filterCondition a rdf:Property ; - rdfs:label "filterCondition" ; - rdfs:comment "Package: The model-level evaluable Boolean-valued Expression used to filter the members of this Package, which are owned by the Package are via ElementFilterMemberships." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:flowConnectionDefinition a rdf:Property ; - rdfs:label "flowConnectionDefinition" ; - rdfs:comment "FlowConnectionUsage: The Interactions that are the types of this FlowConnectionUsage. Nominally, these are FlowConnectionDefinitions, but other kinds of Kernel Interactions are also allowed, to permit use of Interactions from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:framedConcern a rdf:Property ; - rdfs:label "framedConcern" ; - rdfs:comment """RequirementUsage: The ConcernUsages framed by this RequirementUsage, which are the ownedConcerns of all FramedConcernMemberships of the RequirementUsage. -RequirementDefinition: The ConcernUsages framed by this RequirementDefinition, which are the ownedConcerns of all FramedConcernMemberships of the RequirementDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:function a rdf:Property ; - rdfs:label "function" ; - rdfs:comment "Expression: The Function that types this Expression." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:general a rdf:Property ; - rdfs:label "general" ; - rdfs:comment "Specialization: A Type with a superset of all instances of the specific Type, which might be the same set." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:guard a oslc_sysml:TransitionFeatureKind ; - rdfs:label "guard" ; - rdfs:comment "Indicates that the transitionFeature of a TransitionFeatureMembership is a guardExpression." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:guardExpression a rdf:Property ; - rdfs:label "guardExpression" ; - rdfs:comment """Succession: Expressions that must evaluate to true before the transitionStep can occur. -TransitionUsage: The Expressions that define the guards of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = guard, which must all be Expressions.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ifArgument a rdf:Property ; - rdfs:label "ifArgument" ; - rdfs:comment "IfActionUsage: The Expression whose result determines whether the thenAction or (optionally) the elseAction is performed. It is the first parameter of the IfActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:importOwningNamespace a rdf:Property ; - rdfs:label "importOwningNamespace" ; - rdfs:comment "Import: The Namespace into which Memberships are imported by this Import, which must be the owningRelatedElement of the Import." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:importedElement a rdf:Property ; - rdfs:label "importedElement" ; - rdfs:comment "Import: The effectively imported Element for this Import. For a MembershipImport, this is the memberElement of the importedMembership. For a NamespaceImport, it is the importedNamespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:importedMembership a rdf:Property ; - rdfs:label "importedMembership" ; - rdfs:comment """Namespace: The Memberships in this Namespace that result from the ownedImports of this Namespace. -MembershipImport: The Membership to be imported.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:importedNamespace a rdf:Property ; - rdfs:label "importedNamespace" ; - rdfs:comment "NamespaceImport: The Namespace whose visible Memberships are imported by this NamespaceImport." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:in a oslc_sysml:FeatureDirectionKind ; - rdfs:label "in" ; - rdfs:comment "Values of the Feature on each instance of its domain are determined externally to that instance and used internally." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:includedUseCase a rdf:Property ; - rdfs:label "includedUseCase" ; - rdfs:comment """UseCaseUsage: The UseCaseUsages that are included by this UseCaseUse, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseUsage. -UseCaseDefinition: The UseCaseUsages that are included by this UseCaseDefinition, which are the useCaseIncludeds of the IncludeUseCaseUsages owned by this UseCaseDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:individualDefinition a rdf:Property ; - rdfs:label "individualDefinition" ; - rdfs:comment "OccurrenceUsage: The at most one occurrenceDefinition that has isIndividual = true." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:inheritedFeature a rdf:Property ; - rdfs:label "inheritedFeature" ; - rdfs:comment "Type: All the memberFeatures of the inheritedMemberships of this Type that are FeatureMemberships." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:inheritedMembership a rdf:Property ; - rdfs:label "inheritedMembership" ; - rdfs:comment "Type: All Memberships inherited by this Type via Specialization or Conjugation. These are included in the derived union for the memberships of the Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:inout a oslc_sysml:FeatureDirectionKind ; - rdfs:label "inout" ; - rdfs:comment "Values of the Feature on each instance are determined either as in or out directions, or both." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:input a rdf:Property ; - rdfs:label "input" ; - rdfs:comment "Type: All features related to this Type by FeatureMemberships that have direction in or inout." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:interaction a rdf:Property ; - rdfs:label "interaction" ; - rdfs:comment "ItemFlow: The Interactions that type this ItemFlow. Interactions are both Associations and Behaviors, which can type Connectors and Steps, respectively." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:interfaceDefinition a rdf:Property ; - rdfs:label "interfaceDefinition" ; - rdfs:comment "InterfaceUsage: The InterfaceDefinitions that type this InterfaceUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:interfaceEnd a rdf:Property ; - rdfs:label "interfaceEnd" ; - rdfs:comment """InterfaceDefinition: The PortUsages that are the connectionEnds of this InterfaceDefinition. - -.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:intersectingType a rdf:Property ; - rdfs:label "intersectingType" ; - rdfs:comment """Type: The interpretations of a Type with intersectingTypes are asserted to be those in common among the intersectingTypes, which are the Types derived from the intersectingType of the ownedIntersectings of this Type. For example, a Classifier might be an intersection of Classifiers for people of a particular sex and of a particular nationality. Similarly, a feature for people's children of a particular sex might be the intersection of a Feature for their children and a Classifier for people of that sex (because the interpretations of the children Feature that identify those of that sex are also interpretations of the Classifier for that sex). -Intersecting: Type that partly determines interpretations of typeIntersected, as described in Type::intersectingType.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:invertingFeature a rdf:Property ; - rdfs:label "invertingFeature" ; - rdfs:comment "FeatureInverting: The Feature that is an inverse of the invertedFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isAbstract a rdf:Property ; - rdfs:label "isAbstract" ; - rdfs:comment "Type: Indicates whether instances of this Type must also be instances of at least one of its specialized Types." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isComposite a rdf:Property ; - rdfs:label "isComposite" ; - rdfs:comment "Feature: Whether the Feature is a composite feature of its featuringType. If so, the values of the Feature cannot exist after its featuring instance no longer does." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isConjugated a rdf:Property ; - rdfs:label "isConjugated" ; - rdfs:comment "Type: Indicates whether this Type has an ownedConjugator." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isDefault a rdf:Property ; - rdfs:label "isDefault" ; - rdfs:comment "FeatureValue: Whether this FeatureValue is a concrete specification of the bound or initial value of the featureWithValue, or just a default value that may be overridden." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isDerived a rdf:Property ; - rdfs:label "isDerived" ; - rdfs:comment "Feature: Whether the values of this Feature can always be computed from the values of other Features." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isEnd a rdf:Property ; - rdfs:label "isEnd" ; - rdfs:comment "Feature: Whether or not the this Feature is an end Feature, requiring a different interpretation of the multiplicity of the Feature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isImplied a rdf:Property ; - rdfs:label "isImplied" ; - rdfs:comment "Relationship: Whether this Relationship was generated by tooling to meet semantic rules, rather than being directly created by a modeler." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isImpliedIncluded a rdf:Property ; - rdfs:label "isImpliedIncluded" ; - rdfs:comment "Element: Whether all necessary implied Relationships have been included in the ownedRelationships of this Element. This property may be true, even if there are not actually any ownedRelationships with isImplied = true, meaning that no such Relationships are actually implied for this Element. However, if it is false, then ownedRelationships may not contain any implied Relationships. That is, either all required implied Relationships must be included, or none of them." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isImportAll a rdf:Property ; - rdfs:label "isImportAll" ; - rdfs:comment "Import: Whether to import memberships without regard to declared visibility." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isIndividual a rdf:Property ; - rdfs:label "isIndividual" ; - rdfs:comment """OccurrenceUsage: Whether this OccurrenceUsage represents the usage of the specific individual (or portion of it) represented by its individualDefinition. -OccurrenceDefinition: Whether this OccurrenceDefinition is constrained to represent single individual.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isInitial a rdf:Property ; - rdfs:label "isInitial" ; - rdfs:comment "FeatureValue: Whether this FeatureValue specifies a bound value or an initial value for the featureWithValue." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isLibraryElement a rdf:Property ; - rdfs:label "isLibraryElement" ; - rdfs:comment "Element: Whether this Element is contained in the ownership tree of a library model." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isModelLevelEvaluable a rdf:Property ; - rdfs:label "isModelLevelEvaluable" ; - rdfs:comment """Expression: Whether this Expression meets the constraints necessary to be evaluated at model level, that is, using metadata within the model. -Function: Whether this Function can be used as the function of a model-level evaluable InvocationExpression. Certain Functions from the Kernel Functions Library are considered to have isModelLevelEvaluable = true. For all other Functions it is false.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isNegated a rdf:Property ; - rdfs:label "isNegated" ; - rdfs:comment "Invariant: Whether this Invariant is asserted to be false rather than true." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isNonunique a rdf:Property ; - rdfs:label "isNonunique" ; - rdfs:comment "Feature: isNonunique." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isOrdered a rdf:Property ; - rdfs:label "isOrdered" ; - rdfs:comment "Feature: Whether an order exists for the values of this Feature or not." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isParallel a rdf:Property ; - rdfs:label "isParallel" ; - rdfs:comment """StateUsage: Whether the nestedStates of this StateUsage are to all be performed in parallel. If true, none of the nestedActions (which include nestedStates) may have any incoming or outgoing Transitions. If false, only one nestedState may be performed at a time. -StateDefinition: Whether the ownedStates of this StateDefinition are to all be performed in parallel. If true, none of the ownedActions (which includes ownedStates) may have any incoming or outgoing Transitions. If false, only one ownedState may be performed at a time.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isPortion a rdf:Property ; - rdfs:label "isPortion" ; - rdfs:comment "Feature: Whether the values of this Feature are contained in the space and time of instances of the domain of the Feature and represent the same thing as those instances." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isReadOnly a rdf:Property ; - rdfs:label "isReadOnly" ; - rdfs:comment "Feature: Whether the values of this Feature can change over the lifetime of an instance of the domain." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isRecursive a rdf:Property ; - rdfs:label "isRecursive" ; - rdfs:comment "Import: Whether to recursively import Memberships from visible, owned sub-Namespaces." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isReference a rdf:Property ; - rdfs:label "isReference" ; - rdfs:comment "Usage: Whether this Usage is a referential Usage, that is, it has isComposite = false." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isStandard a rdf:Property ; - rdfs:label "isStandard" ; - rdfs:comment "LibraryPackage: Whether this LibraryPackage contains a standard library model. This should only be set to true for LibraryPackages in the standard Kernel Model Libraries or in normative model libraries for a language built on KerML." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isSufficient a rdf:Property ; - rdfs:label "isSufficient" ; - rdfs:comment "Type: Whether all things that meet the classification conditions of this Type must be classified by the Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isUnique a rdf:Property ; - rdfs:label "isUnique" ; - rdfs:comment "Feature: Whether or not values for this Feature must have no duplicates or not." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:isVariation a rdf:Property ; - rdfs:label "isVariation" ; - rdfs:comment """Usage: Whether this Usage is for a variation point or not. If true, then all the memberships of the Usage must be VariantMemberships. -Definition: Whether this Definition is for a variation point or not. If true, then all the memberships of the Definition must be VariantMemberships.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:itemDefinition a rdf:Property ; - rdfs:label "itemDefinition" ; - rdfs:comment "ItemUsage: The Structures that are the definitions of this ItemUsage. Nominally, these are ItemDefinitions, but other kinds of Kernel Structures are also allowed, to permit use of Structures from the Kernel Library." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:itemFeature a rdf:Property ; - rdfs:label "itemFeature" ; - rdfs:comment "ItemFlow: The ownedFeature of the ItemFlow that is an ItemFeature (if any)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:itemFlowEnd a rdf:Property ; - rdfs:label "itemFlowEnd" ; - rdfs:comment "ItemFlow: The connectorEnds of this ItemFlow that are ItemFlowEnds." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:itemType a rdf:Property ; - rdfs:label "itemType" ; - rdfs:comment "ItemFlow: The type of values transferred, which is the type of the itemFeature of the ItemFlow." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:kind a rdf:Property ; - rdfs:label "kind" ; - rdfs:comment """StateSubactionMembership: Whether this StateSubactionMembership is for an entry, do or exit ActionUsage. -TransitionFeatureMembership: Whether this TransitionFeatureMembership is for a trigger, guard or effect. -RequirementConstraintMembership: Whether the RequirementConstraintMembership is for an assumed or required ConstraintUsage. -TriggerInvocationExpression: Indicates which of the Functions from the Triggers model in the Kernel Semantic Library is to be invoked by this TriggerInvocationExpression.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:language a rdf:Property ; - rdfs:label "language" ; - rdfs:comment "TextualRepresentation: The natural or artifical language in which the body text is written." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:lifeClass a rdf:Property ; - rdfs:label "lifeClass" ; - rdfs:comment "OccurrenceDefinition: If isIndividual is true, a LifeClass that specializes this OccurrenceDefinition, restricting it to represent an individual." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:locale a rdf:Property ; - rdfs:label "locale" ; - rdfs:comment "Comment: Identification of the language of the body text and, optionally, the region and/or encoding. The format shall be a POSIX locale conformant to ISO/IEC 15897, with the format [language[_territory][.codeset][@modifier]]." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:loopVariable a rdf:Property ; - rdfs:label "loopVariable" ; - rdfs:comment "ForLoopActionUsage: The ownedFeature of this ForLoopActionUsage that acts as the loop variable, which is assigned the successive values of the input sequence on each iteration. It is the ownedFeature that redefines ForLoopAction::var." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:lowerBound a rdf:Property ; - rdfs:label "lowerBound" ; - rdfs:comment "MultiplicityRange: The Expression whose result provides the lower bound of the MultiplicityRange. If no lowerBound Expression is given, then the lower bound shall have the same value as the upper bound, unless the upper bound is unbounded (*), in which case the lower bound shall be 0." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:member a rdf:Property ; - rdfs:label "member" ; - rdfs:comment "Namespace: The set of all member Elements of this Namespace, which are the memberElements of all memberships of the Namespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:memberElement a rdf:Property ; - rdfs:label "memberElement" ; - rdfs:comment "Membership: The Element that becomes a member of the membershipOwningNamespace due to this Membership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:memberElementId a rdf:Property ; - rdfs:label "memberElementId" ; - rdfs:comment "Membership: The elementId of the memberElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:memberName a rdf:Property ; - rdfs:label "memberName" ; - rdfs:comment "Membership: The name of the memberElement relative to the membershipOwningNamespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:memberShortName a rdf:Property ; - rdfs:label "memberShortName" ; - rdfs:comment "Membership: The short name of the memberElement relative to the membershipOwningNamespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:membership a rdf:Property ; - rdfs:label "membership" ; - rdfs:comment "Namespace: All Memberships in this Namespace, including (at least) the union of ownedMemberships and importedMemberships." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:membershipOwningNamespace a rdf:Property ; - rdfs:label "membershipOwningNamespace" ; - rdfs:comment "Membership: The Namespace of which the memberElement becomes a member due to this Membership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:metaclass a rdf:Property ; - rdfs:label "metaclass" ; - rdfs:comment "MetadataFeature: The type of this MetadataFeature, which must be a Metaclass." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:metadataDefinition a rdf:Property ; - rdfs:label "metadataDefinition" ; - rdfs:comment "MetadataUsage: The MetadataDefinition that is the definition of this MetadataUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:multiplicity a rdf:Property ; - rdfs:label "multiplicity" ; - rdfs:comment "Type: An ownedMember of this Type that is a Multiplicity, which constraints the cardinality of the Type. If there is no such ownedMember, then the cardinality of this Type is constrained by all the Multiplicity constraints applicable to any direct supertypes." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:name a rdf:Property ; - rdfs:label "name" ; - rdfs:comment "Element: The name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveName() operation. By default, it is the same as the declaredName, but this is overridden for certain kinds of Elements to compute a name even when the declaredName is null." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedAction a rdf:Property ; - rdfs:label "nestedAction" ; - rdfs:comment "Usage: The ActionUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedAllocation a rdf:Property ; - rdfs:label "nestedAllocation" ; - rdfs:comment "Usage: The AllocationUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedAnalysisCase a rdf:Property ; - rdfs:label "nestedAnalysisCase" ; - rdfs:comment "Usage: The AnalysisCaseUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedAttribute a rdf:Property ; - rdfs:label "nestedAttribute" ; - rdfs:comment "Usage: The code>AttributeUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedCalculation a rdf:Property ; - rdfs:label "nestedCalculation" ; - rdfs:comment "Usage: The CalculationUsage that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedCase a rdf:Property ; - rdfs:label "nestedCase" ; - rdfs:comment "Usage: The CaseUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedConcern a rdf:Property ; - rdfs:label "nestedConcern" ; - rdfs:comment "Usage: The ConcernUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedConnection a rdf:Property ; - rdfs:label "nestedConnection" ; - rdfs:comment "Usage: The ConnectorAsUsages that are nestedUsages of this Usage. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedConstraint a rdf:Property ; - rdfs:label "nestedConstraint" ; - rdfs:comment "Usage: The ConstraintUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedEnumeration a rdf:Property ; - rdfs:label "nestedEnumeration" ; - rdfs:comment "Usage: The code>EnumerationUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedFlow a rdf:Property ; - rdfs:label "nestedFlow" ; - rdfs:comment "Usage: The code>FlowConnectionUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedInterface a rdf:Property ; - rdfs:label "nestedInterface" ; - rdfs:comment "Usage: The InterfaceUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedItem a rdf:Property ; - rdfs:label "nestedItem" ; - rdfs:comment "Usage: The ItemUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedMetadata a rdf:Property ; - rdfs:label "nestedMetadata" ; - rdfs:comment "Usage: The MetadataUsages that are nestedUsages of this of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedOccurrence a rdf:Property ; - rdfs:label "nestedOccurrence" ; - rdfs:comment "Usage: The OccurrenceUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedPart a rdf:Property ; - rdfs:label "nestedPart" ; - rdfs:comment "Usage: The PartUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedPort a rdf:Property ; - rdfs:label "nestedPort" ; - rdfs:comment "Usage: The PortUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedReference a rdf:Property ; - rdfs:label "nestedReference" ; - rdfs:comment "Usage: The ReferenceUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedRendering a rdf:Property ; - rdfs:label "nestedRendering" ; - rdfs:comment "Usage: The RenderingUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedRequirement a rdf:Property ; - rdfs:label "nestedRequirement" ; - rdfs:comment "Usage: The RequirementUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedState a rdf:Property ; - rdfs:label "nestedState" ; - rdfs:comment "Usage: The StateUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedTransition a rdf:Property ; - rdfs:label "nestedTransition" ; - rdfs:comment "Usage: The TransitionUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedUsage a rdf:Property ; - rdfs:label "nestedUsage" ; - rdfs:comment "Usage: The Usages that are ownedFeatures of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedUseCase a rdf:Property ; - rdfs:label "nestedUseCase" ; - rdfs:comment "Usage: The UseCaseUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedVerificationCase a rdf:Property ; - rdfs:label "nestedVerificationCase" ; - rdfs:comment "Usage: The VerificationCaseUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedView a rdf:Property ; - rdfs:label "nestedView" ; - rdfs:comment "Usage: The ViewUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:nestedViewpoint a rdf:Property ; - rdfs:label "nestedViewpoint" ; - rdfs:comment "Usage: The ViewpointUsages that are nestedUsages of this Usage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:objectiveRequirement a rdf:Property ; - rdfs:label "objectiveRequirement" ; - rdfs:comment """CaseUsage: The RequirementUsage representing the objective of this CaseUsage. -CaseDefinition: The RequirementUsage representing the objective of this CaseDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:occurrenceDefinition a rdf:Property ; - rdfs:label "occurrenceDefinition" ; - rdfs:comment "OccurrenceUsage: The Classes that are the types of this OccurrenceUsage. Nominally, these are OccurrenceDefinitions, but other kinds of kernel Classes are also allowed, to permit use of Classes from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:operand a rdf:Property ; - rdfs:label "operand" ; - rdfs:comment "InvocationExpression: operand." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:operator a rdf:Property ; - rdfs:label "operator" ; - rdfs:comment "OperatorExpression: An operator symbol that names a corresponding Function from one of the standard packages from the Kernel Function Library ." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:originalPortDefinition a rdf:Property ; - rdfs:label "originalPortDefinition" ; - rdfs:comment """ConjugatedPortDefinition: The original PortDefinition for this ConjugatedPortDefinition, which is the owningNamespace of the ConjugatedPortDefinition. -PortConjugation: The PortDefinition being conjugated.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:originalType a rdf:Property ; - rdfs:label "originalType" ; - rdfs:comment "Conjugation: The Type to be conjugated." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:out a oslc_sysml:FeatureDirectionKind ; - rdfs:label "out" ; - rdfs:comment "Values of the Feature on each instance of its domain are determined internally to that instance and used externally." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:output a rdf:Property ; - rdfs:label "output" ; - rdfs:comment "Type: All features related to this Type by FeatureMemberships that have direction out or inout." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAction a rdf:Property ; - rdfs:label "ownedAction" ; - rdfs:comment "Definition: The ActionUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedActorParameter a rdf:Property ; - rdfs:label "ownedActorParameter" ; - rdfs:comment "ActorMembership: The PartUsage specifying the actor." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAllocation a rdf:Property ; - rdfs:label "ownedAllocation" ; - rdfs:comment "Definition: The AllocationUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAnalysisCase a rdf:Property ; - rdfs:label "ownedAnalysisCase" ; - rdfs:comment "Definition: The AnalysisCaseUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAnnotatingRelationship a rdf:Property ; - rdfs:label "ownedAnnotatingRelationship" ; - rdfs:comment "AnnotatingElement: The ownedRelationships of this AnnotatingElement that are Annotations, for which this AnnotatingElement is the annotatingElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAnnotation a rdf:Property ; - rdfs:label "ownedAnnotation" ; - rdfs:comment "Element: The ownedRelationships of this Element that are Annotations, for which this Element is the annotatedElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedAttribute a rdf:Property ; - rdfs:label "ownedAttribute" ; - rdfs:comment "Definition: The AttributeUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedCalculation a rdf:Property ; - rdfs:label "ownedCalculation" ; - rdfs:comment "Definition: The CalculationUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedCase a rdf:Property ; - rdfs:label "ownedCase" ; - rdfs:comment "Definition: The code>CaseUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedConcern a rdf:Property ; - rdfs:label "ownedConcern" ; - rdfs:comment """Definition: The ConcernUsages that are ownedUsages of this Definition. -FramedConcernMembership: The ConcernUsage that is the ownedConstraint of this FramedConcernMembership.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedConjugator a rdf:Property ; - rdfs:label "ownedConjugator" ; - rdfs:comment "Type: A Conjugation owned by this Type for which the Type is the originalType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedConnection a rdf:Property ; - rdfs:label "ownedConnection" ; - rdfs:comment "Definition: The ConnectorAsUsages that are ownedUsages of this Definition. Note that this list includes BindingConnectorAsUsages and SuccessionAsUsages, even though these are ConnectorAsUsages but not ConnectionUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedConstraint a rdf:Property ; - rdfs:label "ownedConstraint" ; - rdfs:comment """Definition: The ConstraintUsages that are ownedUsages of this Definition. -RequirementConstraintMembership: The ConstraintUsage that is the ownedMemberFeature of this RequirementConstraintMembership.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedDifferencing a rdf:Property ; - rdfs:label "ownedDifferencing" ; - rdfs:comment "Type: The ownedRelationships of this Type that are Differencings, having this Type as their typeDifferenced." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedDisjoining a rdf:Property ; - rdfs:label "ownedDisjoining" ; - rdfs:comment "Type: The ownedRelationships of this Type that are Disjoinings, for which the Type is the typeDisjoined Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedElement a rdf:Property ; - rdfs:label "ownedElement" ; - rdfs:comment "Element: The Elements owned by this Element, derived as the ownedRelatedElements of the ownedRelationships of this Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedEndFeature a rdf:Property ; - rdfs:label "ownedEndFeature" ; - rdfs:comment "Type: All endFeatures of this Type that are ownedFeatures." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedEnumeration a rdf:Property ; - rdfs:label "ownedEnumeration" ; - rdfs:comment "Definition: The EnumerationUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedFeature a rdf:Property ; - rdfs:label "ownedFeature" ; - rdfs:comment "Type: The ownedMemberFeatures of the ownedFeatureMemberships of this Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedFeatureChaining a rdf:Property ; - rdfs:label "ownedFeatureChaining" ; - rdfs:comment "Feature: The ownedRelationships of this Feature that are FeatureChainings, for which the Feature will be the featureChained." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedFeatureInverting a rdf:Property ; - rdfs:label "ownedFeatureInverting" ; - rdfs:comment "Feature: The ownedRelationships of this Feature that are FeatureInvertings and for which the Feature is the featureInverted." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedFeatureMembership a rdf:Property ; - rdfs:label "ownedFeatureMembership" ; - rdfs:comment "Type: The ownedMemberships of this Type that are FeatureMemberships, for which the Type is the owningType. Each such FeatureMembership identifies an ownedFeature of the Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedFlow a rdf:Property ; - rdfs:label "ownedFlow" ; - rdfs:comment "Definition: The FlowConnectionUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedImport a rdf:Property ; - rdfs:label "ownedImport" ; - rdfs:comment "Namespace: The ownedRelationships of this Namespace that are Imports, for which the Namespace is the importOwningNamespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedInterface a rdf:Property ; - rdfs:label "ownedInterface" ; - rdfs:comment "Definition: The InterfaceUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedIntersecting a rdf:Property ; - rdfs:label "ownedIntersecting" ; - rdfs:comment "Type: The ownedRelationships of this Type that are Intersectings, have the Type as their typeIntersected." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedItem a rdf:Property ; - rdfs:label "ownedItem" ; - rdfs:comment "Definition: The ItemUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMember a rdf:Property ; - rdfs:label "ownedMember" ; - rdfs:comment "Namespace: The owned members of this Namespace, which are the ownedMemberElements of the ownedMemberships of the Namespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberElement a rdf:Property ; - rdfs:label "ownedMemberElement" ; - rdfs:comment "OwningMembership: The Element that becomes an ownedMember of the membershipOwningNamespace due to this OwningMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberElementId a rdf:Property ; - rdfs:label "ownedMemberElementId" ; - rdfs:comment "OwningMembership: The elementId of the ownedMemberElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberFeature a rdf:Property ; - rdfs:label "ownedMemberFeature" ; - rdfs:comment "FeatureMembership: The Feature that this FeatureMembership relates to its owningType, making it an ownedFeature of the owningType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberName a rdf:Property ; - rdfs:label "ownedMemberName" ; - rdfs:comment "OwningMembership: The name of the ownedMemberElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberParameter a rdf:Property ; - rdfs:label "ownedMemberParameter" ; - rdfs:comment "ParameterMembership: The Feature that is identified as a parameter by this ParameterMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMemberShortName a rdf:Property ; - rdfs:label "ownedMemberShortName" ; - rdfs:comment "OwningMembership: The shortName of the ownedMemberElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMembership a rdf:Property ; - rdfs:label "ownedMembership" ; - rdfs:comment "Namespace: The ownedRelationships of this Namespace that are Memberships, for which the Namespace is the membershipOwningNamespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedMetadata a rdf:Property ; - rdfs:label "ownedMetadata" ; - rdfs:comment "Definition: The MetadataUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedObjectiveRequirement a rdf:Property ; - rdfs:label "ownedObjectiveRequirement" ; - rdfs:comment "ObjectiveMembership: The RequirementUsage that is the ownedMemberFeature of this RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedOccurrence a rdf:Property ; - rdfs:label "ownedOccurrence" ; - rdfs:comment "Definition: The OccurrenceUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedPart a rdf:Property ; - rdfs:label "ownedPart" ; - rdfs:comment "Definition: The PartUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedPort a rdf:Property ; - rdfs:label "ownedPort" ; - rdfs:comment "Definition: The PortUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedPortConjugator a rdf:Property ; - rdfs:label "ownedPortConjugator" ; - rdfs:comment "ConjugatedPortDefinition: The PortConjugation that is the ownedConjugator of this ConjugatedPortDefinition, linking it to its originalPortDefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedRedefinition a rdf:Property ; - rdfs:label "ownedRedefinition" ; - rdfs:comment "Feature: The ownedSubsettings of this Feature that are Redefinitions, for which the Feature is the redefiningFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedReference a rdf:Property ; - rdfs:label "ownedReference" ; - rdfs:comment "Definition: The ReferenceUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedReferenceSubsetting a rdf:Property ; - rdfs:label "ownedReferenceSubsetting" ; - rdfs:comment "Feature: The one ownedSubsetting of this Feature, if any, that is a ReferenceSubsetting, for which the Feature is the referencingFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedRelatedElement a rdf:Property ; - rdfs:label "ownedRelatedElement" ; - rdfs:comment "Relationship: The relatedElements of this Relationship that are owned by the Relationship." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedRelationship a rdf:Property ; - rdfs:label "ownedRelationship" ; - rdfs:comment "Element: The Relationships for which this Element is the owningRelatedElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedRendering a rdf:Property ; - rdfs:label "ownedRendering" ; - rdfs:comment """Definition: The RenderingUsages that are ownedUsages of this Definition. -ViewRenderingMembership: The owned RenderingUsage that is either itself the referencedRendering or subsets the referencedRendering.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedRequirement a rdf:Property ; - rdfs:label "ownedRequirement" ; - rdfs:comment """Definition: The RequirementUsages that are ownedUsages of this Definition. -RequirementVerificationMembership: The owned RequirementUsage that acts as the ownedConstraint for this RequirementVerificationMembership. This will either be the verifiedRequirement, or it will subset the verifiedRequirement.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedResultExpression a rdf:Property ; - rdfs:label "ownedResultExpression" ; - rdfs:comment "ResultExpressionMembership: The Expression that provides the result for the owner of the ResultExpressionMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedSpecialization a rdf:Property ; - rdfs:label "ownedSpecialization" ; - rdfs:comment "Type: The ownedRelationships of this Type that are Specializations, for which the Type is the specific Type." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedStakeholderParameter a rdf:Property ; - rdfs:label "ownedStakeholderParameter" ; - rdfs:comment "StakeholderMembership: The PartUsage specifying the stakeholder." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedState a rdf:Property ; - rdfs:label "ownedState" ; - rdfs:comment "Definition: The StateUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedSubclassification a rdf:Property ; - rdfs:label "ownedSubclassification" ; - rdfs:comment "Classifier: The ownedSpecializations of this Classifier that are Subclassifications, for which this Classifier is the subclassifier." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedSubjectParameter a rdf:Property ; - rdfs:label "ownedSubjectParameter" ; - rdfs:comment "SubjectMembership: The UsageownedMemberParameter of this SubjectMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedSubsetting a rdf:Property ; - rdfs:label "ownedSubsetting" ; - rdfs:comment "Feature: The ownedSpecializations of this Feature that are Subsettings, for which the Feature is the subsettingFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedTransition a rdf:Property ; - rdfs:label "ownedTransition" ; - rdfs:comment "Definition: The TransitionUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedTypeFeaturing a rdf:Property ; - rdfs:label "ownedTypeFeaturing" ; - rdfs:comment "Feature: The ownedRelationships of this Feature that are TypeFeaturings and for which the Feature is the featureOfType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedTyping a rdf:Property ; - rdfs:label "ownedTyping" ; - rdfs:comment "Feature: The ownedSpecializations of this Feature that are FeatureTypings, for which the Feature is the typedFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedUnioning a rdf:Property ; - rdfs:label "ownedUnioning" ; - rdfs:comment "Type: The ownedRelationships of this Type that are Unionings, having the Type as their typeUnioned." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedUsage a rdf:Property ; - rdfs:label "ownedUsage" ; - rdfs:comment "Definition: The Usages that are ownedFeatures of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedUseCase a rdf:Property ; - rdfs:label "ownedUseCase" ; - rdfs:comment "Definition: The UseCaseUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedVariantUsage a rdf:Property ; - rdfs:label "ownedVariantUsage" ; - rdfs:comment "VariantMembership: The Usage that represents a variant in the context of the owningVariationDefinition or owningVariationUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedVerificationCase a rdf:Property ; - rdfs:label "ownedVerificationCase" ; - rdfs:comment "Definition: The VerificationCaseUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedView a rdf:Property ; - rdfs:label "ownedView" ; - rdfs:comment "Definition: The ViewUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:ownedViewpoint a rdf:Property ; - rdfs:label "ownedViewpoint" ; - rdfs:comment "Definition: The ViewpointUsages that are ownedUsages of this Definition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owner a rdf:Property ; - rdfs:label "owner" ; - rdfs:comment "Element: The owner of this Element, derived as the owningRelatedElement of the owningRelationship of this Element, if any." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningAnnotatedElement a rdf:Property ; - rdfs:label "owningAnnotatedElement" ; - rdfs:comment "Annotation: The annotatedElement of this Annotation, when it is also its owningRelatedElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningAnnotatingElement a rdf:Property ; - rdfs:label "owningAnnotatingElement" ; - rdfs:comment "Annotation: The annotatingElement of this Annotation, when it is also its owningRelatedElement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningClassifier a rdf:Property ; - rdfs:label "owningClassifier" ; - rdfs:comment "Subclassification: The Classifier that owns this Subclassification relationship, which must also be its subclassifier." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningDefinition a rdf:Property ; - rdfs:label "owningDefinition" ; - rdfs:comment "Usage: The Definition that owns this Usage (if any)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningFeature a rdf:Property ; - rdfs:label "owningFeature" ; - rdfs:comment """Subsetting: A subsettingFeature that is also the owningRelatedElement of this Subsetting. -FeatureTyping: A typedFeature that is also the owningRelatedElement of this FeatureTyping. -FeatureInverting: A featureInverted that is also the owningRelatedElement of this FeatureInverting.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningFeatureMembership a rdf:Property ; - rdfs:label "owningFeatureMembership" ; - rdfs:comment "Feature: The FeatureMembership that owns this Feature as an ownedMemberFeature, determining its owningType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningFeatureOfType a rdf:Property ; - rdfs:label "owningFeatureOfType" ; - rdfs:comment "TypeFeaturing: A featureOfType that is also the owningRelatedElement of this TypeFeaturing." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningMembership a rdf:Property ; - rdfs:label "owningMembership" ; - rdfs:comment "Element: The owningRelationship of this Element, if that Relationship is a Membership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningNamespace a rdf:Property ; - rdfs:label "owningNamespace" ; - rdfs:comment "Element: The Namespace that owns this Element, which is the membershipOwningNamespace of the owningMembership of this Element, if any." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningRelatedElement a rdf:Property ; - rdfs:label "owningRelatedElement" ; - rdfs:comment "Relationship: The relatedElement of this Relationship that owns the Relationship, if any." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningRelationship a rdf:Property ; - rdfs:label "owningRelationship" ; - rdfs:comment "Element: The Relationship for which this Element is an ownedRelatedElement, if any." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningType a rdf:Property ; - rdfs:label "owningType" ; - rdfs:comment """Specialization: The Type that is the specific Type of this Specialization and owns it as its owningRelatedElement. -FeatureMembership: The Type that owns this FeatureMembership. -Feature: The Type that is the owningType of the owningFeatureMembership of this Feature. -Conjugation: The conjugatedType of this Conjugation that is also its owningRelatedElement. -Disjoining: A typeDisjoined that is also an owningRelatedElement.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:owningUsage a rdf:Property ; - rdfs:label "owningUsage" ; - rdfs:comment "Usage: The Usage in which this Usage is nested (if any)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:parameter a rdf:Property ; - rdfs:label "parameter" ; - rdfs:comment """Behavior: The parameters of this Behavior, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Behavior. -Step: The parameters of this Step, which are defined as its directedFeatures, whose values are passed into and/or out of a performance of the Step.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:partDefinition a rdf:Property ; - rdfs:label "partDefinition" ; - rdfs:comment "PartUsage: The itemDefinitions of this PartUsage that are PartDefinitions." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:payloadArgument a rdf:Property ; - rdfs:label "payloadArgument" ; - rdfs:comment """AcceptActionUsage: An Expression whose result is bound to the payload parameter of this AcceptActionUsage. If provided, the AcceptActionUsage will only accept a Transfer with exactly this payload. -SendActionUsage: An Expression whose result is bound to the payload input parameter of this SendActionUsage.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:payloadParameter a rdf:Property ; - rdfs:label "payloadParameter" ; - rdfs:comment "AcceptActionUsage: The nestedReference of this AcceptActionUsage that redefines the payload output parameter of the base AcceptActionUsage AcceptAction from the Systems Model Library." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:performedAction a rdf:Property ; - rdfs:label "performedAction" ; - rdfs:comment "PerformActionUsage: The ActionUsage to be performed by this PerformedActionUsage. It is the eventOccurrence of the PerformActionUsage considered as an EventOccurrenceUsage, which must be an ActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:portDefinition a rdf:Property ; - rdfs:label "portDefinition" ; - rdfs:comment """PortUsage: The occurrenceDefinitions of this PortUsage, which must all be PortDefinitions. -ConjugatedPortTyping: The originalPortDefinition of the conjugatedPortDefinition of this ConjugatedPortTyping.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:portionKind a rdf:Property ; - rdfs:label "portionKind" ; - rdfs:comment "OccurrenceUsage: The kind of (temporal) portion of the life of the occurrenceDefinition represented by this OccurrenceUsage, if it is so restricted." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:predicate a rdf:Property ; - rdfs:label "predicate" ; - rdfs:comment "BooleanExpression: The Predicate that types this BooleanExpression." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:private a oslc_sysml:VisibilityKind ; - rdfs:label "private" ; - rdfs:comment "Indicates a Membership is not visible outside its owning Namespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:protected a oslc_sysml:VisibilityKind ; - rdfs:label "protected" ; - rdfs:comment "An intermediate level of visibility between public and private. By default, it is equivalent to private for the purposes of normal access to and import of Elements from a Namespace. However, other Relationships may be specified to include Memberships with protected visibility in the list of memberships for a Namespace (e.g., Specialization)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:public a oslc_sysml:VisibilityKind ; - rdfs:label "public" ; - rdfs:comment "Indicates that a Membership is publicly visible outside its owning Namespace." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:qualifiedName a rdf:Property ; - rdfs:label "qualifiedName" ; - rdfs:comment "Element: The full ownership-qualified name of this Element, represented in a form that is valid according to the KerML textual concrete syntax for qualified names (including use of unrestricted name notation and escaped characters, as necessary). The qualifiedName is null if this Element has no owningNamespace or if there is not a complete ownership chain of named Namespaces from a root Namespace to this Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:receiverArgument a rdf:Property ; - rdfs:label "receiverArgument" ; - rdfs:comment """AcceptActionUsage: An Expression whose result is bound to the receiver input parameter of this AcceptActionUsage. -SendActionUsage: An Expression whose result is bound to the receiver input parameter of this SendActionUsage.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:redefinedFeature a rdf:Property ; - rdfs:label "redefinedFeature" ; - rdfs:comment "Redefinition: The Feature that is redefined by the redefiningFeature of this Redefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:redefiningFeature a rdf:Property ; - rdfs:label "redefiningFeature" ; - rdfs:comment "Redefinition: The Feature that is redefining the redefinedFeature of this Redefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencedConcern a rdf:Property ; - rdfs:label "referencedConcern" ; - rdfs:comment "FramedConcernMembership: The ConcernUsage that is referenced through this FramedConcernMembership. It is the referencedConstraint of the FramedConcernMembership considered as a RequirementConstraintMembership, which must be a ConcernUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencedConstraint a rdf:Property ; - rdfs:label "referencedConstraint" ; - rdfs:comment "RequirementConstraintMembership: The ConstraintUsage that is referenced through this RequirementConstraintMembership. It is the referencedFeature of the ownedReferenceSubsetting of the ownedConstraint, if there is one, and, otherwise, the ownedConstraint itself." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencedElement a rdf:Property ; - rdfs:label "referencedElement" ; - rdfs:comment "MetadataAccessExpression: The Element whose metadata is being accessed." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencedFeature a rdf:Property ; - rdfs:label "referencedFeature" ; - rdfs:comment "ReferenceSubsetting: The Feature that is referenced by the referencingFeature of this ReferenceSubsetting." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencedRendering a rdf:Property ; - rdfs:label "referencedRendering" ; - rdfs:comment "ViewRenderingMembership: The RenderingUsage that is referenced through this ViewRenderingMembership. It is the referencedFeature of the ownedReferenceSubsetting for the ownedRendering, if there is one, and, otherwise, the ownedRendering itself." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referencingFeature a rdf:Property ; - rdfs:label "referencingFeature" ; - rdfs:comment "ReferenceSubsetting: The Feature that owns this ReferenceSubsetting relationship, which is also its subsettingFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:referent a rdf:Property ; - rdfs:label "referent" ; - rdfs:comment """FeatureReferenceExpression: The Feature that is referenced by this FeatureReferenceExpression, which is its first non-parameter member. -AssignmentActionUsage: The Feature whose value is to be set.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:relatedElement a rdf:Property ; - rdfs:label "relatedElement" ; - rdfs:comment "Relationship: The Elements that are related by this Relationship, derived as the union of the source and target Elements of the Relationship." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:relatedFeature a rdf:Property ; - rdfs:label "relatedFeature" ; - rdfs:comment "Connector: The Features that are related by this Connector considered as a Relationship and that restrict the links it identifies, given by the referenced Features of the connectorEnds of the Connector." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:relatedType a rdf:Property ; - rdfs:label "relatedType" ; - rdfs:comment "Association: The types of the associationEnds of the Association, which are the relatedElements of the Association considered as a Relationship." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:rendering a rdf:Property ; - rdfs:label "rendering" ; - rdfs:comment "RenderingDefinition: The usages of a RenderingDefinition that are RenderingUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:renderingDefinition a rdf:Property ; - rdfs:label "renderingDefinition" ; - rdfs:comment "RenderingUsage: The RenderingDefinition that is the definition of this RenderingUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:representedElement a rdf:Property ; - rdfs:label "representedElement" ; - rdfs:comment "TextualRepresentation: The Element that is represented by this TextualRepresentation." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:reqId a rdf:Property ; - rdfs:label "reqId" ; - rdfs:comment """RequirementUsage: An optional modeler-specified identifier for this RequirementUsage (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementUsage. -RequirementDefinition: An optional modeler-specified identifier for this RequirementDefinition (used, e.g., to link it to an original requirement text in some source document), which is the declaredShortName for the RequirementDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:requiredConstraint a rdf:Property ; - rdfs:label "requiredConstraint" ; - rdfs:comment """RequirementUsage: The owned ConstraintUsages that represent requirements of this RequirementUsage, which are the ownedConstraints of the RequirementConstraintMemberships of the RequirementUsage with kind = requirement. -RequirementDefinition: The owned ConstraintUsages that represent requirements of this RequirementDefinition, derived as the ownedConstraints of the RequirementConstraintMemberships of the RequirementDefinition with kind = requirement.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:requirement a oslc_sysml:RequirementConstraintKind ; - rdfs:label "requirement" ; - rdfs:comment "Indicates that a member ConstraintUsage of a RequirementDefinition or RequirementUsagerepresents an requirement." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:requirementDefinition a rdf:Property ; - rdfs:label "requirementDefinition" ; - rdfs:comment "RequirementUsage: The RequirementDefinition that is the single definition of this RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:result a rdf:Property ; - rdfs:label "result" ; - rdfs:comment """Expression: result. -Function: The result parameter of the Function, which is owned by the Function via a ReturnParameterMembership.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:resultExpression a rdf:Property ; - rdfs:label "resultExpression" ; - rdfs:comment """AnalysisCaseUsage: An Expression used to compute the result of the AnalysisCaseUsage, owned via a ResultExpressionMembership. -AnalysisCaseDefinition: An Expression used to compute the result of the AnalysisCaseDefinition, owned via a ResultExpressionMembership.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:satisfiedRequirement a rdf:Property ; - rdfs:label "satisfiedRequirement" ; - rdfs:comment "SatisfyRequirementUsage: The RequirementUsage that is satisfied by the satisfyingSubject of this SatisfyRequirementUsage. It is the assertedConstraint of the SatisfyRequirementUsage considered as an AssertConstraintUsage, which must be a RequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:satisfiedViewpoint a rdf:Property ; - rdfs:label "satisfiedViewpoint" ; - rdfs:comment """ViewUsage: The nestedRequirements of this ViewUsage that are ViewpointUsages for (additional) viewpoints satisfied by the ViewUsage. -ViewDefinition: The composite ownedRequirements of this ViewDefinition that are ViewpointUsages for viewpoints satisfied by the ViewDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:satisfyingFeature a rdf:Property ; - rdfs:label "satisfyingFeature" ; - rdfs:comment "SatisfyRequirementUsage: The Feature that represents the actual subject that is asserted to satisfy the satisfiedRequirement. The satisfyingFeature is bound to the subjectParameter of the SatisfyRequirementUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:senderArgument a rdf:Property ; - rdfs:label "senderArgument" ; - rdfs:comment "SendActionUsage: An Expression whose result is bound to the sender input parameter of this SendActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:seqArgument a rdf:Property ; - rdfs:label "seqArgument" ; - rdfs:comment "ForLoopActionUsage: The Expression whose result provides the sequence of values to which the loopVariable is set for each iterative performance of the bodyAction. It is the Expression whose result is bound to the seq input parameter of this ForLoopActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:shortName a rdf:Property ; - rdfs:label "shortName" ; - rdfs:comment "Element: The short name to be used for this Element during name resolution within its owningNamespace. This is derived using the effectiveShortName() operation. By default, it is the same as the declaredShortName, but this is overridden for certain kinds of Elements to compute a shortName even when the declaredName is null." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:snapshot a oslc_sysml:PortionKind ; - rdfs:label "snapshot" ; - rdfs:comment "A snapshot of an Occurrence (a time slice with zero duration)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:source a rdf:Property ; - rdfs:label "source" ; - rdfs:comment """Relationship: The relatedElements from which this Relationship is considered to be directed. -TransitionUsage: The source ActionUsage of this TransitionUsage, which becomes the source of the succession for the TransitionUsage.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:sourceFeature a rdf:Property ; - rdfs:label "sourceFeature" ; - rdfs:comment "Connector: The source relatedFeature for this Connector. It is the first relatedFeature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:sourceOutputFeature a rdf:Property ; - rdfs:label "sourceOutputFeature" ; - rdfs:comment "ItemFlow: The Feature that provides the items carried by the ItemFlow. It must be an owned output of the source of the ItemFlow." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:sourceType a rdf:Property ; - rdfs:label "sourceType" ; - rdfs:comment "Association: The source relatedType for this Association. It is the first relatedType of the Association." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:specific a rdf:Property ; - rdfs:label "specific" ; - rdfs:comment "Specialization: A Type with a subset of all instances of the general Type, which might be the same set." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:stakeholderParameter a rdf:Property ; - rdfs:label "stakeholderParameter" ; - rdfs:comment """RequirementUsage: The parameters of this RequirementUsage that represent stakeholders for the requirement. -RequirementDefinition: The parameters of this RequirementDefinition that represent stakeholders for th requirement.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:state a rdf:Property ; - rdfs:label "state" ; - rdfs:comment "StateDefinition: The StateUsages, which are actions in the StateDefinition, that specify the discrete states in the behavior defined by the StateDefinition." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:stateDefinition a rdf:Property ; - rdfs:label "stateDefinition" ; - rdfs:comment "StateUsage: The Behaviors that are the types of this StateUsage. Nominally, these would be StateDefinitions, but kernel Behaviors are also allowed, to permit use of Behaviors from the Kernel Model Libraries." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:step a rdf:Property ; - rdfs:label "step" ; - rdfs:comment "Behavior: The Steps that make up this Behavior." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:subclassifier a rdf:Property ; - rdfs:label "subclassifier" ; - rdfs:comment "Subclassification: The more specific Classifier in this Subclassification." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:subjectParameter a rdf:Property ; - rdfs:label "subjectParameter" ; - rdfs:comment """RequirementUsage: The parameter of this RequirementUsage that represents its subject. -RequirementDefinition: The parameter of this RequirementDefinition that represents its subject. -CaseUsage: The parameter of this CaseUsage that represents its subject. -CaseDefinition: The parameter of this CaseDefinition that represents its subject.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:subsettedFeature a rdf:Property ; - rdfs:label "subsettedFeature" ; - rdfs:comment "Subsetting: The Feature that is subsetted by the subsettingFeature of this Subsetting." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:subsettingFeature a rdf:Property ; - rdfs:label "subsettingFeature" ; - rdfs:comment "Subsetting: The Feature that is a subset of the subsettedFeature of this Subsetting." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:succession a rdf:Property ; - rdfs:label "succession" ; - rdfs:comment "TransitionUsage: The Succession that is the ownedFeature of this TransitionUsage, which, if the TransitionUsage is triggered, asserts the temporal ordering of the source and target." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:superclassifier a rdf:Property ; - rdfs:label "superclassifier" ; - rdfs:comment "Subclassification: The more general Classifier in this Subclassification." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:supplier a rdf:Property ; - rdfs:label "supplier" ; - rdfs:comment "Dependency: The Element or Elements on which the client Elements depend in some respect." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:target a rdf:Property ; - rdfs:label "target" ; - rdfs:comment """Relationship: The relatedElements to which this Relationship is considered to be directed. -TransitionUsage: The target ActionUsage of this TransitionUsage, which is the targetFeature of the succession for the TransitionUsage.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:targetArgument a rdf:Property ; - rdfs:label "targetArgument" ; - rdfs:comment "AssignmentActionUsage: The Expression whose value is an occurrence in the domain of the referent Feature, for which the value of the referent will be set to the result of the valueExpression by this AssignmentActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:targetFeature a rdf:Property ; - rdfs:label "targetFeature" ; - rdfs:comment """Connector: The target relatedFeatures for this Connector. This includes all the relatedFeatures other than the sourceFeature. -FeatureChainExpression: The Feature that is accessed by this FeatureChainExpression, which is its first non-parameter member.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:targetInputFeature a rdf:Property ; - rdfs:label "targetInputFeature" ; - rdfs:comment "ItemFlow: The Feature that receives the values carried by the ItemFlow. It must be an owned output of the target participant of the ItemFlow." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:targetType a rdf:Property ; - rdfs:label "targetType" ; - rdfs:comment "Association: The target relatedTypes for this Association. This includes all the relatedTypes other than the sourceType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:terminatedOccurrenceArgument a rdf:Property ; - rdfs:label "terminatedOccurrenceArgument" ; - rdfs:comment "TerminateActionUsage: The Expression that is the featureValue of the terminateOccurrence parameter of this TerminateActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:text a rdf:Property ; - rdfs:label "text" ; - rdfs:comment """RequirementUsage: An optional textual statement of the requirement represented by this RequirementUsage, derived from the bodies of the documentation of the RequirementUsage. -RequirementDefinition: An optional textual statement of the requirement represented by this RequirementDefinition, derived from the bodies of the documentation of the RequirementDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:textualRepresentation a rdf:Property ; - rdfs:label "textualRepresentation" ; - rdfs:comment "Element: The TextualRepresentations that annotate this Element." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:thenAction a rdf:Property ; - rdfs:label "thenAction" ; - rdfs:comment "IfActionUsage: The ActionUsage that is to be performed if the result of the ifArgument is true. It is the second parameter of the IfActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:timeslice a oslc_sysml:PortionKind ; - rdfs:label "timeslice" ; - rdfs:comment "A time slice of an Occurrence (a portion over time)." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:transitionFeature a rdf:Property ; - rdfs:label "transitionFeature" ; - rdfs:comment "TransitionFeatureMembership: The Step that is the ownedMemberFeature of this TransitionFeatureMembership." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:transitionStep a rdf:Property ; - rdfs:label "transitionStep" ; - rdfs:comment "Succession: A Step that is typed by the Behavior TransitionPerformances::TransitionPerformance (from the Kernel Semantic Library) that has this Succession as its transitionLink." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:trigger a oslc_sysml:TransitionFeatureKind ; - rdfs:label "trigger" ; - rdfs:comment "Indicates that the transitionFeature of a TransitionFeatureMembership is a triggerAction." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:triggerAction a rdf:Property ; - rdfs:label "triggerAction" ; - rdfs:comment "TransitionUsage: The AcceptActionUsages that define the triggers of this TransitionUsage, which are the ownedFeatures of the TransitionUsage related to it by TransitionFeatureMemberships with kind = trigger, which must all be AcceptActionUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:triggerStep a rdf:Property ; - rdfs:label "triggerStep" ; - rdfs:comment "Succession: Steps that map incoming events to the timing of occurrences of the transitionStep. The values of triggerStep subset the list of acceptable events to be received by a Behavior or the object that performs it." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:type a rdf:Property ; - rdfs:label "type" ; - rdfs:comment """Featuring: The Type that features the featureOfType. -Feature: Types that restrict the values of this Feature, such that the values must be instances of all the types. The types of a Feature are derived from its typings and the types of its subsettings. If the Feature is chained, then the types of the last Feature in the chain are also types of the chained Feature. -FeatureTyping: The Type that is being applied by this FeatureTyping.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:typeDifferenced a rdf:Property ; - rdfs:label "typeDifferenced" ; - rdfs:comment "Differencing: Type with interpretations partly determined by differencingType, as described in Type::differencingType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:typeDisjoined a rdf:Property ; - rdfs:label "typeDisjoined" ; - rdfs:comment "Disjoining: Type asserted to be disjoint with the disjoiningType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:typeIntersected a rdf:Property ; - rdfs:label "typeIntersected" ; - rdfs:comment "Intersecting: Type with interpretations partly determined by intersectingType, as described in Type::intersectingType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:typeUnioned a rdf:Property ; - rdfs:label "typeUnioned" ; - rdfs:comment "Unioning: Type with interpretations partly determined by unioningType, as described in Type::unioningType." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:typedFeature a rdf:Property ; - rdfs:label "typedFeature" ; - rdfs:comment "FeatureTyping: The Feature that has a type determined by this FeatureTyping." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:unioningType a rdf:Property ; - rdfs:label "unioningType" ; - rdfs:comment """Type: The interpretations of a Type with unioningTypes are asserted to be the same as those of all the unioningTypes together, which are the Types derived from the unioningType of the ownedUnionings of this Type. For example, a Classifier for people might be the union of Classifiers for all the sexes. Similarly, a feature for people's children might be the union of features dividing them in the same ways as people in general. -Unioning: Type that partly determines interpretations of typeUnioned, as described in Type::unioningType.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:untilArgument a rdf:Property ; - rdfs:label "untilArgument" ; - rdfs:comment "WhileLoopActionUsage: The Expression whose result, if false, determines that the bodyAction should continue to be performed. It is the (optional) third owned parameter of the WhileLoopActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:upperBound a rdf:Property ; - rdfs:label "upperBound" ; - rdfs:comment "MultiplicityRange: The Expression whose result is the upper bound of the MultiplicityRange." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:usage a rdf:Property ; - rdfs:label "usage" ; - rdfs:comment """Usage: The Usages that are features of this Usage (not necessarily owned). -Definition: The Usages that are features of this Definition (not necessarily owned).""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:useCaseDefinition a rdf:Property ; - rdfs:label "useCaseDefinition" ; - rdfs:comment "UseCaseUsage: The UseCaseDefinition that is the definition of this UseCaseUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:useCaseIncluded a rdf:Property ; - rdfs:label "useCaseIncluded" ; - rdfs:comment "IncludeUseCaseUsage: The UseCaseUsage to be included by this IncludeUseCaseUsage. It is the performedAction of the IncludeUseCaseUsage considered as a PerformActionUsage, which must be a UseCaseUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:value a rdf:Property ; - rdfs:label "value" ; - rdfs:comment """LiteralRational: The value whose rational approximation is the result of evaluating this LiteralRational. -LiteralBoolean: The Boolean value that is the result of evaluating this LiteralBoolean. -LiteralInteger: The Integer value that is the result of evaluating this LiteralInteger. -LiteralString: The String value that is the result of evaluating this LiteralString. -FeatureValue: The Expression that provides the value of the featureWithValue as its result.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:valueExpression a rdf:Property ; - rdfs:label "valueExpression" ; - rdfs:comment "AssignmentActionUsage: The Expression whose result is to be assigned to the referent Feature." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:variant a rdf:Property ; - rdfs:label "variant" ; - rdfs:comment """Usage: The Usages which represent the variants of this Usage as a variation point Usage, if isVariation = true. If isVariation = false, then there must be no variants. -Definition: The Usages which represent the variants of this Definition as a variation point Definition, if isVariation = true. If isVariation = false, the there must be no variants.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:variantMembership a rdf:Property ; - rdfs:label "variantMembership" ; - rdfs:comment """Usage: The ownedMemberships of this Usage that are VariantMemberships. If isVariation = true, then this must be all memberships of the Usage. If isVariation = false, then variantMembershipmust be empty. -Definition: The ownedMemberships of this Definition that are VariantMemberships. If isVariation = true, then this must be all ownedMemberships of the Definition. If isVariation = false, then variantMembershipmust be empty.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:verificationCaseDefinition a rdf:Property ; - rdfs:label "verificationCaseDefinition" ; - rdfs:comment "VerificationCaseUsage: The VerificationCase that is the definition of this VerificationCaseUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:verifiedRequirement a rdf:Property ; - rdfs:label "verifiedRequirement" ; - rdfs:comment """VerificationCaseUsage: The RequirementUsages verified by this VerificationCaseUsage, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement. -VerificationCaseDefinition: The RequirementUsages verified by this VerificationCaseDefinition, which are the verifiedRequirements of all RequirementVerificationMemberships of the objectiveRequirement. -RequirementVerificationMembership: The RequirementUsage that is identified as being verified. It is the referencedConstraint of the RequirementVerificationMembership considered as a RequirementConstraintMembership, which must be a RequirementUsage.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:view a rdf:Property ; - rdfs:label "view" ; - rdfs:comment "ViewDefinition: The usages of this ViewDefinition that are ViewUsages." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:viewCondition a rdf:Property ; - rdfs:label "viewCondition" ; - rdfs:comment """ViewUsage: The Expressions related to this ViewUsage by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view. -ViewDefinition: The Expressions related to this ViewDefinition by ElementFilterMemberships, which specify conditions on Elements to be rendered in a view.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:viewDefinition a rdf:Property ; - rdfs:label "viewDefinition" ; - rdfs:comment "ViewUsage: The ViewDefinition that is the definition of this ViewUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:viewRendering a rdf:Property ; - rdfs:label "viewRendering" ; - rdfs:comment """ViewUsage: The RenderingUsage to be used to render views defined by this ViewUsage, which is the referencedRendering of the ViewRenderingMembership of the ViewUsage. -ViewDefinition: The RenderingUsage to be used to render views defined by this ViewDefinition, which is the referencedRendering of the ViewRenderingMembership of the ViewDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:viewpointDefinition a rdf:Property ; - rdfs:label "viewpointDefinition" ; - rdfs:comment "ViewpointUsage: The ViewpointDefinition that is the definition of this ViewpointUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:viewpointStakeholder a rdf:Property ; - rdfs:label "viewpointStakeholder" ; - rdfs:comment """ViewpointUsage: The PartUsages that identify the stakeholders with concerns framed by this ViewpointUsage, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointUsage. -ViewpointDefinition: The PartUsages that identify the stakeholders with concerns framed by this ViewpointDefinition, which are the owned and inherited stakeholderParameters of the framedConcerns of this ViewpointDefinition.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:visibility a rdf:Property ; - rdfs:label "visibility" ; - rdfs:comment """Membership: Whether or not the Membership of the memberElement in the membershipOwningNamespace is publicly visible outside that Namespace. -Import: The visibility level of the imported members from this Import relative to the importOwningNamespace. The default is private.""" ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:when a oslc_sysml:TriggerKind ; - rdfs:label "when" ; - rdfs:comment "Indicates a change trigger, corresponding to the TriggerWhen Function from the Triggers model in the Kernel Semantic Library." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml:whileArgument a rdf:Property ; - rdfs:label "whileArgument" ; - rdfs:comment "WhileLoopActionUsage: The Expression whose result, if true, determines that the bodyAction should continue to be performed. It is the first owned parameter of the WhileLoopActionUsage." ; - rdfs:isDefinedBy oslc_sysml: . - -oslc_sysml: a owl:Ontology ; - rdfs:label "OSLC SysML v2 Vocabulary" ; - dcterms:dateCopyrighted "2012-2024" ; - dcterms:description "All vocabulary URIs defined in the OSLC SysML v2 namespace."^^rdf:XMLLiteral ; - dcterms:hasVersion "PSD01" ; - dcterms:isPartOf ; - dcterms:issued "2024-08-01"^^xsd:date ; - dcterms:license ; - dcterms:publisher ; - dcterms:source ; - dcterms:title "OSLC SysML v2 Vocabulary" ; - vann:preferredNamespacePrefix "oslc_sysml" . - From d22916b7aa90b015021cd4189f54859cff135c4f Mon Sep 17 00:00:00 2001 From: Jim Amsden Date: Thu, 12 Dec 2024 10:42:03 -0500 Subject: [PATCH 4/5] Ran prettier --- specs/plm/plm-spec.html | 13 +++++++++---- specs/plm/plm-vocab.html | 4 ++-- 2 files changed, 11 insertions(+), 6 deletions(-) diff --git a/specs/plm/plm-spec.html b/specs/plm/plm-spec.html index 4e20295..1667685 100644 --- a/specs/plm/plm-spec.html +++ b/specs/plm/plm-spec.html @@ -290,12 +290,17 @@

Terminology

-
+

Overview

- This specification defines a vocabulary for OSLC Product Lifecycle Management resources. The intent is to define resources needed to support common integration scenarios and not to provide a comprehensive definition of product lifecycle management resources. -

- The following is an overview of the PLM specification. The specification includes classes: Part, PartUsage, LogicalDesign and PhysicalDesign, and Dimension; links between these within the PLM domain and links to classes in other OSLC domains. + This specification defines a vocabulary for OSLC Product Lifecycle Management resources. The intent is to define + resources needed to support common integration scenarios and not to provide a comprehensive definition of + product lifecycle management resources. +

+

+ The following is an overview of the PLM specification. The specification includes classes: Part, PartUsage, + LogicalDesign and PhysicalDesign, and Dimension; links between these within the PLM domain and links to classes + in other OSLC domains.

diff --git a/specs/plm/plm-vocab.html b/specs/plm/plm-vocab.html index 7c062bc..6de995c 100644 --- a/specs/plm/plm-vocab.html +++ b/specs/plm/plm-vocab.html @@ -247,8 +247,8 @@

Terminology

dcterms and foaf defined in the OSLC Core specification, OSLC PLM defines the namespace URI of http://open-services.net/ns/plm# with a namespace - prefix of oslc_plm + >, OSLC PLM defines the namespace URI of http://open-services.net/ns/plm# with a namespace prefix + of oslc_plm

This specification also uses these namespace prefix definitions:

From 0e69f71b88394205a204c4b845d07878c9a39965 Mon Sep 17 00:00:00 2001 From: Jim Amsden Date: Thu, 12 Dec 2024 10:45:12 -0500 Subject: [PATCH 5/5] Ran prettier on config --- specs/config/config-resources.html | 15 ++++----------- specs/config/oslc-config-mgt.html | 2 +- specs/config/versioned-resources.html | 6 +++--- 3 files changed, 8 insertions(+), 15 deletions(-) diff --git a/specs/config/config-resources.html b/specs/config/config-resources.html index 9d37ebf..8e6dfa1 100644 --- a/specs/config/config-resources.html +++ b/specs/config/config-resources.html @@ -146,8 +146,7 @@ CORS: { title: "Fetch standard", authors: ["WHATWG contributors"], - href: - "https://fetch.spec.whatwg.org/commit-snapshots/d070ea245c6eb66cf4196324f063dc6ab608d9e6/#http-cors-protocol", + href: "https://fetch.spec.whatwg.org/commit-snapshots/d070ea245c6eb66cf4196324f063dc6ab608d9e6/#http-cors-protocol", status: "Living Standard", publisher: "WHATWG", }, @@ -461,9 +460,7 @@

Supported Operations on Components

A configuration server SHOULD support, and a global configuration server MUST support one or more component creation factories declared in one or more OSLC service providers.

-

- A configuration server SHOULD support one or more query capabilities for components. -

+

A configuration server SHOULD support one or more query capabilities for components.

Supported Operations on Configurations

@@ -586,9 +583,7 @@

Supported Operations on Change Set Delivery

Delivering change sets using a creation factory

-

- There are several key aspects of change set delivery that OSLC Configuration Management should support: -

+

There are several key aspects of change set delivery that OSLC Configuration Management should support:

  1. Delivery is atomic. Either all the changed/new/removed resources are delivered, or none are.
  2. A delivery might be a long-running operation.
    3. @@ -659,9 +654,7 @@

    Delivery Conflicts

Change Set Delivery History

-

- There are several common uses cases for finding information about change set deliveries: -

+

There are several common uses cases for finding information about change set deliveries:

  • When was a specified change set delivered to a specified stream, and by whom?
  • Which streams has a specified change set been delivered to?
    • diff --git a/specs/config/oslc-config-mgt.html b/specs/config/oslc-config-mgt.html index 0eff530..691c8d2 100644 --- a/specs/config/oslc-config-mgt.html +++ b/specs/config/oslc-config-mgt.html @@ -494,7 +494,7 @@

    Acknowledgements

    The following individuals have participated in the creation of this specification and are gratefully acknowledged:

    -

    +

    David Honey (Persistent)
    Ian Green (Persistent)
    Geoff Clemm (Persistent)
    diff --git a/specs/config/versioned-resources.html b/specs/config/versioned-resources.html index 76b41a1..ba61c1a 100644 --- a/specs/config/versioned-resources.html +++ b/specs/config/versioned-resources.html @@ -229,9 +229,9 @@

    Delegated UIs

    Compact Rendering

    - A versioned resource server SHOULD implement compact rendering (resource preview), both for concept resources and version - resources. See Compact Rendering for the handling of configuration - context in such rendering. + A versioned resource server SHOULD implement compact rendering (resource preview), both for concept resources + and version resources. See Compact Rendering for the handling of + configuration context in such rendering.