From addc9f80c17e8e2235531817b54a55bf72e49950 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sat, 3 Oct 2026 20:39:47 +0000 Subject: [PATCH 01/10] fix(export): load sysml-toolkit api-json exports Co-Authored-By: jason.han --- .../unreleased/toolkit-json-import.fixed.md | 1 + cmd/sysml/convert.go | 4 +- cmd/sysml/convert_test.go | 23 + docs/reference/rdf-mapping.md | 20 +- internal/translate/convert/api_json_test.go | 33 + internal/translate/convert/convert.go | 14 +- internal/translate/export/api_json_out.go | 5 +- internal/translate/export/behavior.go | 103 +- internal/translate/export/callee_test.go | 2 +- internal/translate/export/end_forms.go | 180 +- internal/translate/export/kinds.go | 5 + internal/translate/export/names.go | 173 +- internal/translate/export/rdf_in.go | 313 +- internal/translate/export/rdf_in_normative.go | 49 +- internal/translate/export/rdf_in_toolkit.go | 117 +- .../translate/export/rdf_normative_test.go | 225 + internal/translate/export/rdf_out.go | 19 +- internal/translate/export/root_namespace.go | 21 +- tests/export/testdata/interchange/README.md | 1 + .../interchange/flow_ends.golden.sysml | 14 + .../testdata/interchange/flow_ends.sysml | 14 + .../interchange/flow_ends.toolkit.full.json | 5567 +++++++ .../interchange/library_identity.golden.sysml | 8 + .../interchange/library_identity.sysml | 9 + .../library_identity.toolkit.full.json | 1213 ++ .../library_unmatched.toolkit.full.json | 1213 ++ .../interchange/successions.golden.sysml | 8 + .../testdata/interchange/successions.sysml | 7 + .../interchange/successions.toolkit.full.json | 2652 ++++ .../interchange/transitions.golden.sysml | 13 + .../testdata/interchange/transitions.sysml | 15 + .../interchange/transitions.toolkit.full.json | 12712 ++++++++++++++++ tests/export/toolkit_json_import_test.go | 223 + tests/export/variation_rdf_test.go | 24 + 34 files changed, 24841 insertions(+), 159 deletions(-) create mode 100644 changes/unreleased/toolkit-json-import.fixed.md create mode 100644 tests/export/testdata/interchange/README.md create mode 100644 tests/export/testdata/interchange/flow_ends.golden.sysml create mode 100644 tests/export/testdata/interchange/flow_ends.sysml create mode 100644 tests/export/testdata/interchange/flow_ends.toolkit.full.json create mode 100644 tests/export/testdata/interchange/library_identity.golden.sysml create mode 100644 tests/export/testdata/interchange/library_identity.sysml create mode 100644 tests/export/testdata/interchange/library_identity.toolkit.full.json create mode 100644 tests/export/testdata/interchange/library_unmatched.toolkit.full.json create mode 100644 tests/export/testdata/interchange/successions.golden.sysml create mode 100644 tests/export/testdata/interchange/successions.sysml create mode 100644 tests/export/testdata/interchange/successions.toolkit.full.json create mode 100644 tests/export/testdata/interchange/transitions.golden.sysml create mode 100644 tests/export/testdata/interchange/transitions.sysml create mode 100644 tests/export/testdata/interchange/transitions.toolkit.full.json create mode 100644 tests/export/toolkit_json_import_test.go diff --git a/changes/unreleased/toolkit-json-import.fixed.md b/changes/unreleased/toolkit-json-import.fixed.md new file mode 100644 index 0000000000..6eb27745be --- /dev/null +++ b/changes/unreleased/toolkit-json-import.fixed.md @@ -0,0 +1 @@ +- **Toolkit full-JSON imports preserve flows, transitions, and library references.** Flow ends owned through `EndFeatureMembership` are folded into the flow head; transitions read trigger, guard, and effect features by their membership kind rather than mistaking parameters for effects; and document-defined library packages remain declarations. Library stubs with stale ids can resolve by their stated qualified name or graph-stated name and owner chain, with a warning, while unmatched identities report both the id and name. Apollo API-JSON import avoids rescanning the whole graph for each owner. diff --git a/cmd/sysml/convert.go b/cmd/sysml/convert.go index 0907ca1a26..abdc76c9c0 100644 --- a/cmd/sysml/convert.go +++ b/cmd/sysml/convert.go @@ -384,7 +384,9 @@ func convertRecorded(input string, to convert.Format) (int, error) { // convertOptions are the conversion settings -id asks for, refusing it for a // direction it does not apply to. func convertOptions(from, to convert.Format) (convert.Options, error) { - opts := convert.Options{} + opts := convert.Options{Warn: func(message string) { + fmt.Fprintf(os.Stderr, "warning: %s\n", message) + }} if idForm == "" { return opts, nil } diff --git a/cmd/sysml/convert_test.go b/cmd/sysml/convert_test.go index 61211c8d74..cdc4c279f8 100644 --- a/cmd/sysml/convert_test.go +++ b/cmd/sysml/convert_test.go @@ -120,6 +120,29 @@ func TestConvertToStdout(t *testing.T) { } } +func TestConvertAPIJSONLibraryFallbackWarnsOnStderr(t *testing.T) { + binary := buildCLI(t) + data, err := os.ReadFile(filepath.Join("..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json")) + if err != nil { + t.Fatal(err) + } + input := filepath.Join(t.TempDir(), "library.json") + if err := os.WriteFile(input, data, 0o644); err != nil { + t.Fatal(err) + } + result := runCommand(t, exec.Command(binary, input, "-from", "api-json", "-convert", "sysml")) + if result.status != 0 { + t.Fatalf("conversion exited %d:\n%s%s", result.status, result.stdout, result.stderr) + } + if !strings.Contains(result.stderr, "warning: the library element") || + !strings.Contains(result.stderr, "resolved by its qualified name ScalarValues::Real") { + t.Errorf("the library identity warning was not written to stderr:\n%s", result.stderr) + } + if strings.Contains(result.stdout, "warning:") || !strings.Contains(result.stdout, "library package DocumentLibrary") { + t.Errorf("stdout contains the wrong conversion output:\n%s", result.stdout) + } +} + // TestConvertFlagOrder checks that the model may be named before or after the // flags that apply to it, since Go's flag package stops at the first file name // unless the arguments are reordered. diff --git a/docs/reference/rdf-mapping.md b/docs/reference/rdf-mapping.md index e51300ab29..9d12566bac 100644 --- a/docs/reference/rdf-mapping.md +++ b/docs/reference/rdf-mapping.md @@ -270,8 +270,15 @@ take it (`LibraryReference`). Reading a graph back, such an element is a reference into the bundled library, not a declaration, and it is not written. A qualified name other than the one -the library gives its id is refused rather than trusted, and so is an id the -library does not have. Repository sync never creates, changes or deletes one. +the library gives its id is refused rather than trusted. If the id is not in +the catalog, the reader tries the stated qualified name; without one, it uses +the stated declared name and an owner chain the graph itself states. A match +must have a compatible metaclass. A fallback match is written by its bundled +identity and reports a warning with both ids and the name used; an unmatched +stub is refused with its id and stated name. A `library package` that owns +content in the document is a declaration, even when it states +`sysml:isLibraryElement true`, and is written as notation rather than treated +as a reference stub. Repository sync never creates, changes or deletes one. **What is a version of a library file.** A document is a version of a bundled library file when every one of its roots is a top-level package that file @@ -383,6 +390,8 @@ triples come); a set of classes with no such member is refused, naming the subje `isOrdered`, `isNonunique`, `isEnd`, `isConstant`, `isIndividual`, `isPortion`, `isConjugated`, `isAll`, `isAccept`, `isResult`, and `isEvent` for an `event` modifier on a usage whose metaclass is not itself `sysml:EventOccurrenceUsage`. + `sysml:EnumerationDefinition` has no `abstract` or `variation` prefix, so + neither flag adds a keyword to its declaration. A flag the two grammars spell differently is written back in the grammar of its root (`sysx:sourceLanguage`): `isConstant` as KerML's `const` or SysML's `constant`; `isPortion` as KerML's `portion`, in place of `composite` (a @@ -1285,7 +1294,7 @@ the node, that name is used; the rest are `sysx:` terms, marked below. | `state s { … }`, `state s parallel { … }`, `entry; then s; state s;` | `sysml:StateUsage` | `sysml:declaredName`, `sysx:declaredKeyword`, `sysml:isParallel`, its members | | `entry`/`do`/`exit`, `entry do { … }` (whatever separates the `do` from the body) | `sysml:StateSubactionMembership` | `sysml:kind` (`entry`, `do`, `exit`) beside `sysx:subactionKind`, `sysx:declaredKeyword`, the one action it performs, which a `perform a;` states as a `sysml:PerformActionUsage` and an empty `entry;` as an anonymous `sysml:ActionUsage` with no name and no body; a braced block `entry { … }` is an anonymous `sysml:ActionUsage` with `sysx:isKindImplicit` (no `action` keyword was written) whose `sysx:hasBody` is the braces. A graph from an older mapping that wrote a braced block as its statements under the membership, `sysx:hasBody` on the membership itself, is refused as unsupported: it holds no anonymous action to read the block back as | | `choice`, `junction`, `fork`, `join`, `shallow`/`deep history` | `sysx:Pseudostate` | `sysx:pseudostateKind`, `sysx:declaredKeyword` | -| `transition [n] [first] s [accept t] [if g] [do e] then t;`, `… then t { … }` | `sysml:TransitionUsage` | `sysml:source`, `sysml:target`; ahead of everything else it owns, the `FeatureChainMember` naming the source of a `first` transition — a `sysml:Membership` whose member is the state, or for `first a.b` a `sysml:OwningMembership` owning the chain `sysml:Feature` — then an `EmptyParameterMember` (a `sysml:ParameterMembership` owning an undeclared `sysml:ReferenceUsage`, direction `in`), and a second one ahead of a trigger (SysML-textual-bnf `TransitionUsage`, `TargetTransitionUsage`); and the `then` succession it owns through a `sysml:OwningMembership` — a `sysml:SuccessionAsUsage` (SysML.xtext `TransitionSuccessionMember`) stated as `sysml:succession`, whose first end is the empty source end and whose second end's `ReferenceSubsetting` names the target, or for `then b.c` owns the chain it references; the source member, parameters and succession are implied — never written back, a chained source or target written as its chain — and one that disagrees with the head's `sysml:source`/`sysml:target`, a chain by its last link, is refused — plus its trigger as metamodel structure (below), `sysx:guard`, `sysx:transitionSyntax`, its effect and body as members: the effect is owned through a `sysml:TransitionFeatureMembership` with `sysml:kind "effect"` and `sysml:transitionFeature` (SysML v2 1.0 § 8.3.18.8), the transition stating it as `sysml:effectAction`, and the collapsed `sysx:effectMember`, `sysx:bodyMember` links are written beside; a graph carrying either form alone reads, and one whose `TransitionFeatureMembership` and `sysx:effectMember` name different members is refused, with `sysx:hasEffect` on every transition written with `do` (its braced effect `do { … }` is an anonymous action as for a state's `entry { … }`, so an empty `do { }` survives as that action's `sysx:hasBody`) and `sysx:hasBody` for a trailing body; a graph with members linked by neither owns an effect alone, `sysx:hasBody` its braces. A graph from an older mapping that wrote a braced effect as its statements (`sysx:bracedEffect`, or `sysx:hasBody` on an unlinked effect) is refused as unsupported: it holds no anonymous action to read the block back as. The trigger is the transition's `sysml:triggerAction`, a `sysml:AcceptActionUsage` owned through a `sysml:TransitionFeatureMembership` with `sysml:kind "trigger"` and `sysml:transitionFeature` (formal/2026-03-02 § 8.3.17.9, SysML.xtext `TriggerActionMember`), as the pinned pilot builds it: its payload is a `sysml:ParameterMembership`-owned `sysml:payloadParameter` (`sysml:isAccept`, direction `in`), named as written and typed through a `sysml:FeatureTyping` (`accept Sig` is an unnamed payload typed `Sig`, `accept c : Cmd` a payload `c`); `via p` is the accept action's `sysml:receiverArgument`, the `sysml:FeatureReferenceExpression` to `p` a second parameter binds; `after d`, `at t` and `when c` are the payload's value and the accept action's `sysml:payloadArgument`, a `sysml:TriggerInvocationExpression` with `sysml:kind` `"after"`, `"at"` or `"when"` and its one argument (a `when` condition through a `sysml:FeatureReferenceExpression`, as the pilot writes it). `sysx:triggerKeyword "when"` is written beside that structure only for the change trigger spelled without `accept` (`transition first s1 when c then s2`), a notation choice. The OpenSysML-only `when `, which names a signal the runtime injects rather than a Boolean condition, has no metamodel form and keeps the extension predicates `sysx:trigger` (the name) and `sysx:triggerKeyword "when"`. A graph an earlier mapping wrote, with the trigger as `sysx:trigger` text, `sysx:triggerKeyword` and the port as `sysml:via`, still reads; a `sysx:trigger` or `sysml:via` stated beside the structure must name the same payload, types and port (each name compared by the element it reaches from the transition through its enclosing namespaces or the standard library, so `T::Sig` and `Sig`, `T::'Stop Signal'` and `'Stop Signal'`, or a global `$::T::Sig` agree; a name only an import or inheritance brings into scope, such as `Real` under `import ScalarValues::*`, agrees when it ends the qualified name the other reaches), or the graph is refused rather than one of them dropped. Likewise a `sysml:triggerAction` naming an action other than the one the trigger membership owns, a `sysml:payloadParameter` naming another parameter than the one flagged `sysml:isAccept`, a `sysml:payloadArgument` other than the payload parameter's value, more than one valued receiver parameter, and a valued receiver parameter no `sysml:receiverArgument` names (or one it disagrees with) are refused | +| `transition [n] [first] s [accept t] [if g] [do e] then t;`, `… then t { … }` | `sysml:TransitionUsage` | `sysml:source`, `sysml:target`; ahead of everything else it owns, the `FeatureChainMember` naming the source of a `first` transition — a `sysml:Membership` whose member is the state, or for `first a.b` a `sysml:OwningMembership` owning the chain `sysml:Feature` — then an `EmptyParameterMember` (a `sysml:ParameterMembership` owning an undeclared `sysml:ReferenceUsage`, direction `in`), and a second one ahead of a trigger (SysML-textual-bnf `TransitionUsage`, `TargetTransitionUsage`); and the `then` succession it owns through a `sysml:OwningMembership` — a `sysml:SuccessionAsUsage` (SysML.xtext `TransitionSuccessionMember`) stated as `sysml:succession`, whose first end is the empty source end and whose second end's `ReferenceSubsetting` names the target, or for `then b.c` owns the chain it references; the source member, parameters and succession are implied — never written back, a chained source or target written as its chain — and one that disagrees with the head's `sysml:source`/`sysml:target`, a chain by its last link, is refused — plus its trigger as metamodel structure (below), its guard from a `TransitionFeatureMembership` with `sysml:kind "guard"` and `sysml:transitionFeature` (checked against `sysx:guard` when both are stated), `sysml:transitionSyntax`, its effect and body as members: the effect is owned through a `sysml:TransitionFeatureMembership` with `sysml:kind "effect"` and `sysml:transitionFeature` (SysML v2 1.0 § 8.3.18.8), the transition stating it as `sysml:effectAction`, and the collapsed `sysx:effectMember`, `sysx:bodyMember` links are written beside; a graph carrying either form alone reads, and one whose `TransitionFeatureMembership` and `sysx:effectMember` name different members is refused. A `ParameterMembership` is never read as a transition effect. `sysx:hasEffect` is written on every transition written with `do` (its braced effect `do { … }` is an anonymous action as for a state's `entry { … }`, so an empty `do { }` survives as that action's `sysx:hasBody`) and `sysx:hasBody` for a trailing body; a graph with members linked by neither owns an effect alone, `sysx:hasBody` its braces. A graph from an older mapping that wrote a braced effect as its statements (`sysx:bracedEffect`, or `sysx:hasBody` on an unlinked effect) is refused as unsupported: it holds no anonymous action to read the block back as. The trigger is the transition's `sysml:triggerAction`, a `sysml:AcceptActionUsage` owned through a `sysml:TransitionFeatureMembership` with `sysml:kind "trigger"` and `sysml:transitionFeature` (formal/2026-03-02 § 8.3.17.9, SysML.xtext `TriggerActionMember`), as the pinned pilot builds it: its payload is a `sysml:ParameterMembership`-owned `sysml:payloadParameter` (`sysml:isAccept`, direction `in`), named as written and typed through a `sysml:FeatureTyping` (`accept Sig` is an unnamed payload typed `Sig`, `accept c : Cmd` a payload `c`); `via p` is the accept action's `sysml:receiverArgument`, the `sysml:FeatureReferenceExpression` to `p` a second parameter binds; `after d`, `at t` and `when c` are the payload's value and the accept action's `sysml:payloadArgument`, a `sysml:TriggerInvocationExpression` with `sysml:kind` `"after"`, `"at"` or `"when"` and its one argument (a `when` condition through a `sysml:FeatureReferenceExpression`, as the pilot writes it). `sysx:triggerKeyword "when"` is written beside that structure only for the change trigger spelled without `accept` (`transition first s1 when c then s2`), a notation choice. The OpenSysML-only `when `, which names a signal the runtime injects rather than a Boolean condition, has no metamodel form and keeps the extension predicates `sysx:trigger` (the name) and `sysx:triggerKeyword "when"`. A graph an earlier mapping wrote, with the trigger as `sysx:trigger` text, `sysx:triggerKeyword` and the port as `sysml:via`, still reads; a `sysx:trigger` or `sysml:via` stated beside the structure must name the same payload, types and port (each name compared by the element it reaches from the transition through its enclosing namespaces or the standard library, so `T::Sig` and `Sig`, `T::'Stop Signal'` and `'Stop Signal'`, or a global `$::T::Sig` agree; a name only an import or inheritance brings into scope, such as `Real` under `import ScalarValues::*`, agrees when it ends the qualified name the other reaches), or the graph is refused rather than one of them dropped. Likewise a `sysml:triggerAction` naming an action other than the one the trigger membership owns, a `sysml:payloadParameter` naming another parameter than the one flagged `sysml:isAccept`, a `sysml:payloadArgument` other than the payload parameter's value, more than one valued receiver parameter, and a valued receiver parameter no `sysml:receiverArgument` names (or one it disagrees with) are refused | These action-body forms also apply recursively inside their own bodies; a nested statement uses the same RDF mapping as a top-level body item. A @@ -1496,7 +1505,10 @@ expr:P__Car___402_pend0_om ``` A `flow`'s end (and a `succession flow`'s) is a `sysml:FlowEnd` instead -(SysML.xtext FlowEnd), under the same `EndFeatureMembership`. Its +(SysML.xtext FlowEnd), under the same `EndFeatureMembership`; the reader folds +it into the owning flow's `from … to …` head and never writes it as a separate +declaration. A declared name or content the head cannot represent is refused. +Its `ReferenceSubsetting` names all but the last segment of the end as written — the feature itself for `t.fuel`, a chain feature for `a.p.fuel`, nothing for a lone name — and the end owns, through a `sysml:FeatureMembership`, a diff --git a/internal/translate/convert/api_json_test.go b/internal/translate/convert/api_json_test.go index 28dee83d36..de1d798480 100644 --- a/internal/translate/convert/api_json_test.go +++ b/internal/translate/convert/api_json_test.go @@ -3,6 +3,7 @@ package convert_test import ( "errors" "os" + "path/filepath" "strings" "testing" @@ -105,6 +106,38 @@ func TestAPIJSONToolkitCompactFixture(t *testing.T) { } } +func TestLibraryFallbackWarningsReachBothGraphImportPaths(t *testing.T) { + data, err := os.ReadFile(filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json")) + if err != nil { + t.Fatal(err) + } + turtle, err := convert.Convert("library.json", data, convert.FormatAPIJSON, convert.FormatTurtle) + if err != nil { + t.Fatalf("api-json to ttl: %v", err) + } + for _, input := range []struct { + name string + from convert.Format + data []byte + }{ + {name: "api-json", from: convert.FormatAPIJSON, data: data}, + {name: "ttl", from: convert.FormatTurtle, data: turtle}, + } { + t.Run(input.name, func(t *testing.T) { + var warnings []string + _, err := convert.ConvertWith(input.name, input.data, input.from, convert.FormatSysML, convert.Options{ + Warn: func(message string) { warnings = append(warnings, message) }, + }) + if err != nil { + t.Fatalf("%s to sysml: %v", input.name, err) + } + if len(warnings) != 1 || !strings.Contains(warnings[0], "ScalarValues::Real") { + t.Fatalf("warnings = %v", warnings) + } + }) + } +} + // A malformed element document is a syntax error of the input, as a malformed // Turtle document is. func TestAPIJSONSyntaxError(t *testing.T) { diff --git a/internal/translate/convert/convert.go b/internal/translate/convert/convert.go index 92f08f3c3b..0fca4be961 100644 --- a/internal/translate/convert/convert.go +++ b/internal/translate/convert/convert.go @@ -184,7 +184,8 @@ type SyntaxError = parser.SyntaxError type Options struct { // ID is the form derived element ids are written in; the zero value is // qualified-name-derived ids. - ID export.IDForm + ID export.IDForm + Warn func(string) } // Convert reads data in the from format and writes it in the to format. name is @@ -333,7 +334,7 @@ func convert(name string, data []byte, from, to Format, tolerateSyntaxErrors boo if err != nil { return nil, nil, err } - out, err := FromGraph(graph, to) + out, err := FromGraphWith(graph, to, opts) return out, nil, err case from == FormatFMU: @@ -353,7 +354,7 @@ func convert(name string, data []byte, from, to Format, tolerateSyntaxErrors boo if err != nil { return nil, nil, &SyntaxError{Name: name, Messages: []string{err.Error()}} } - out, err := FromGraph(graph, to) + out, err := FromGraphWith(graph, to, opts) return out, nil, err } } @@ -361,9 +362,14 @@ func convert(name string, data []byte, from, to Format, tolerateSyntaxErrors boo // FromGraph writes a graph in the to format, so a graph that did not come // from a Turtle file — a repository branch read as RDF — converts alike. func FromGraph(graph *rdf.Graph, to Format) ([]byte, error) { + return FromGraphWith(graph, to, Options{}) +} + +// FromGraphWith writes a graph in the to format with conversion options. +func FromGraphWith(graph *rdf.Graph, to Format, opts Options) ([]byte, error) { switch { case to == FormatSysML: - return export.ToSysML(graph) + return export.ToSysMLWarn(graph, opts.Warn) case to == FormatTurtle: return rdf.WriteTurtle(graph), nil case to == FormatAPIJSON: diff --git a/internal/translate/export/api_json_out.go b/internal/translate/export/api_json_out.go index caa5f1f54d..0bd7d9b705 100644 --- a/internal/translate/export/api_json_out.go +++ b/internal/translate/export/api_json_out.go @@ -29,8 +29,9 @@ func WriteAPIJSON(graph *rdf.Graph) ([]byte, error) { if err != nil { return nil, err } - elements := make([]apiJSONObject, 0, len(settled.Subjects())) - for _, subject := range settled.Subjects() { + subjects := settled.Subjects() + elements := make([]apiJSONObject, 0, len(subjects)) + for _, subject := range subjects { element, err := apiJSONElement(settled, subject) if err != nil { return nil, err diff --git a/internal/translate/export/behavior.go b/internal/translate/export/behavior.go index 85e4b90e4b..a35c67f6be 100644 --- a/internal/translate/export/behavior.go +++ b/internal/translate/export/behavior.go @@ -90,6 +90,8 @@ const ( // libraryDone is the library feature a `done;` member names. var libraryDone = ast.QualifiedNameOf("Actions", "Action", "done") +var libraryStateStart = ast.QualifiedNameOf("States", "StateAction", "start") + // libraryReference is the subject of a standard library element named from // the global scope, or its name when no library is loaded. func (e *encoder) libraryReference(name *ast.QualifiedName) rdf.Term { @@ -1167,6 +1169,11 @@ func (d *decoder) membershipKeyword(el *element) string { } switch el.metaclass { case mSuccession: + if source, ok := d.graph.Object(rdf.IRI(el.iri), rdf.SysML+pSourceFeature); ok { + if start, err := d.referencedElement(source.Value); err == nil && start.qname == qualifiedText(libraryStateStart) { + return "first" + } + } return "" case mAlias: return "alias" @@ -1510,6 +1517,16 @@ func (d *decoder) successionChild(src *keptSources, child *element) (bool, error from := src.sourceBefore(1) if positionalTarget { from = src.sourceBeforeMember(target) + targetKept := false + for _, member := range src.kept { + if member == target { + targetKept = true + break + } + } + if !targetKept { + from = src.sourceBefore(0) + } } if err := d.attachable(child, from); err != nil { return false, err @@ -1628,7 +1645,11 @@ func (d *decoder) sequencesFrom(el, from *element) bool { return false } if term, positional := d.graph.Object(rdf.IRI(el.iri), rdf.OpenSysML+xSourceMember); positional { - return term.Value == from.iri + if term.Value == from.iri { + return true + } + answers, ok := d.answersTo(from) + return ok && term.Equal(answers) } source, ok := d.graph.Object(rdf.IRI(el.iri), rdf.SysML+pSourceFeature) if !ok { @@ -1898,7 +1919,11 @@ func (d *decoder) transitionText(el *element, annotations []string, depth int) ( return "", "", err } words = append(words, triggerWords...) - if guard, ok := d.stringOf(el, rdf.OpenSysML+xGuard); ok { + guard, err := d.transitionGuard(el) + if err != nil { + return "", "", err + } + if guard != "" { words = append(words, "if", guard) } effect, body, hasEffect, hasBody, err := d.transitionMembers(el) @@ -1920,6 +1945,68 @@ func (d *decoder) transitionText(el *element, annotations []string, depth int) ( return strings.Join(words, " "), bodyText, nil } +func (d *decoder) transitionGuard(el *element) (string, error) { + refuse := func(note string) error { + return &UnsupportedError{What: fmt.Sprintf("the transition <%s>", el.iri), Note: note} + } + subject := rdf.IRI(el.iri) + var guards []rdf.Term + for _, membership := range d.graph.Objects(subject, rdf.SysML+pOwnedFeatureMembership) { + if d.metaclass(membership) != mTransitionFeatureMembership { + continue + } + kind, _ := d.graph.Lexical(membership, rdf.SysML+pKind) + if kind != "guard" { + continue + } + member := firstIRI(d.graph, membership, pMemberElement, pOwnedMemberElement, pOwnedMemberFeature, pOwnedRelatedElement) + if member.Value == "" { + return "", refuse("its TransitionFeatureMembership of kind `guard` names no expression") + } + guards = append(guards, member) + } + if len(guards) > 1 { + return "", refuse(fmt.Sprintf("it owns %d guard features, and the transition notation writes one `if` clause", len(guards))) + } + stated := d.graph.Objects(subject, rdf.SysML+"guardExpression") + if len(stated) > 1 { + return "", refuse("it states more than one sysml:guardExpression, and the transition notation writes one `if` clause") + } + if len(guards) > 0 && len(stated) > 0 && guards[0] != stated[0] { + return "", refuse("its guard membership and sysml:guardExpression name different expressions") + } + var guard rdf.Term + if len(guards) > 0 { + guard = guards[0] + } else if len(stated) > 0 { + guard = stated[0] + } + if guard.Value == "" { + text, _ := d.stringOf(el, rdf.OpenSysML+xGuard) + return text, nil + } + var text string + var err error + if guard.IsLiteral() { + if guard.Datatype != rdf.OpenSysML+dtExpression { + return "", refuse("its guard is a literal that is not a SysML expression") + } + text = guard.Value + } else { + text, err = d.expressionNodeText(guard, el) + if err != nil { + return "", err + } + } + if text == "" { + return "", refuse("its guard expression has no notation") + } + if written, ok := d.stringOf(el, rdf.OpenSysML+xGuard); ok && written != text { + return "", refuse("its sysx:guard text disagrees with the guard expression") + } + return text, nil +} + // effectText writes a transition's `do` effect members. func (d *decoder) effectText(effect []*element, depth int) (string, error) { text, err := d.membersText(effect, false, depth) @@ -2369,9 +2456,8 @@ func (d *decoder) triggerReceiver(el, accepter, payload *element) (string, error return d.expressionNodeText(receiver, el) } -// transitionMembers partitions a transition's members into effect and body: -// members are linked as effect or body; unlinked members are from a mapping -// that owned the effect alone, with sysx:hasBody its braces. +// transitionMembers partitions linked effects and body members. Unlinked legacy +// members are effects only when they are not parameters. func (d *decoder) transitionMembers(el *element) (effect, body []*element, hasEffect, hasBody bool, err error) { inEffect := d.linked(el, xEffectMember) inBody := d.linked(el, xBodyMember) @@ -2396,6 +2482,13 @@ func (d *decoder) transitionMembers(el *element) (effect, body []*element, hasEf } } legacy := len(children) > 0 && len(inEffect) == 0 && len(inBody) == 0 + for _, child := range children { + if m, owned := d.owningMembership[child.iri]; owned && + d.metaclass(rdf.IRI(m.iri)) == mParameterMembership { + legacy = false + break + } + } hasEffect = d.boolOf(el, rdf.OpenSysML+xHasEffect) || (!collapsed && len(inEffect) > 0) hasBody = d.boolOf(el, rdf.OpenSysML+xHasBody) // A braced effect is one anonymous action; a graph that wrote it as the diff --git a/internal/translate/export/callee_test.go b/internal/translate/export/callee_test.go index 1904712b9d..c0a068b3e2 100644 --- a/internal/translate/export/callee_test.go +++ b/internal/translate/export/callee_test.go @@ -29,7 +29,7 @@ func TestCalleeTextChainAgreesByIdentity(t *testing.T) { } d := newDecoder(g, map[rdf.Term]string{ node: rdf.SysML + mInvocation, membership: rdf.SysML + mOwningMembership, chain: rdf.SysML + mFeature, - }, nil) + }, nil, nil) for iri, qname := range map[rdf.Term]string{foo: "Service::foo", other: "Other::foo"} { g.Add(iri, rdf.SysMLTerm(pQualifiedName), rdf.String(qname)) d.byIRI[iri.Value] = &element{iri: iri.Value, qname: qname} diff --git a/internal/translate/export/end_forms.go b/internal/translate/export/end_forms.go index 2de46efb5a..f2e8696d8b 100644 --- a/internal/translate/export/end_forms.go +++ b/internal/translate/export/end_forms.go @@ -637,7 +637,9 @@ func (d *decoder) standardEndFeatures(el *element) ([]rdf.Term, error) { // member is written in its body as `end`, not in its head: the abstract // syntax is the same. func (d *decoder) appendEnd(el *element, terms []rdf.Term, term rdf.Term) []rdf.Term { - if d.declaredChild(el, term) || slices.Contains(terms, term) { + flowEnd := d.byIRI[term.Value] + headFlowEnd := flowEnd != nil && flowEnd.metaclass == mFlowEnd && d.headEnd(flowEnd, el) + if (d.declaredChild(el, term) && !headFlowEnd) || slices.Contains(terms, term) { return terms } return append(terms, term) @@ -866,6 +868,19 @@ func (d *decoder) declaredChild(el *element, term rdf.Term) bool { // standardEndTarget resolves an end through ReferenceSubsetting, then the // interim sysml:references property, refusing conflicting representations. +func referenceSubsettingIndex(graph *rdf.Graph, meta func(rdf.Term) string, subjects []rdf.Term) map[string][]rdf.Term { + index := map[string][]rdf.Term{} + for _, subject := range subjects { + if meta(subject) != mReferenceSubsetting { + continue + } + if referencing, ok := graph.Object(subject, rdf.SysML+pReferencingFeature); ok && referencing.IsIRI() { + index[referencing.Value] = append(index[referencing.Value], subject) + } + } + return index +} + func (d *decoder) standardEndTarget(end rdf.Term, in *element) (rdf.Term, bool, error) { var relationships []rdf.Term appendUnique := func(term rdf.Term) { @@ -882,13 +897,8 @@ func (d *decoder) standardEndTarget(end rdf.Term, in *element) (rdf.Term, bool, } } if len(relationships) == 0 { - for _, subject := range d.graph.Subjects() { - if d.metaclass(subject) != mReferenceSubsetting { - continue - } - if referencing, ok := d.graph.Object(subject, rdf.SysML+pReferencingFeature); ok && referencing == end { - appendUnique(subject) - } + for _, relationship := range d.referenceSubsettings[end.Value] { + appendUnique(relationship) } } var target rdf.Term @@ -981,6 +991,35 @@ func (d *decoder) flowEndText(end rdf.Term, in *element) (string, error) { return text, nil } +func (d *decoder) flowFeatureImplied(el, parent *element) (bool, error) { + if parent == nil || parent.metaclass != mFlowEnd || el.metaclass != mReferenceUsage { + return false, nil + } + membership, owned := d.owningMembership[el.iri] + if !owned || d.metaclass(rdf.IRI(membership.iri)) != mFeatureMembership { + return false, nil + } + subject := rdf.IRI(el.iri) + if d.graph.HasProperty(subject, rdf.SysML+pDeclaredName) || + d.graph.HasProperty(subject, rdf.SysML+pDeclaredShortName) || + len(d.graph.Objects(subject, rdf.SysML+pOwnedAnnotation)) > 0 { + return false, nil + } + relationships := d.graph.Objects(subject, rdf.SysML+pOwnedRelationship) + redefinitions := 0 + for _, relation := range relationships { + meta := d.metaclass(relation) + if meta == mRedefinition { + redefinitions++ + continue + } + if !impliedRelationshipMetaclasses[meta] || !d.graph.BoolValue(relation, rdf.SysML+pIsImplied) { + return false, nil + } + } + return redefinitions == 1, nil +} + // flowEndSegments is the chain a FlowEnd is written as: what its // ReferenceSubsetting names, if anything, then the feature its FlowFeature // redefines. The FlowFeature is found through ownedFeature, else through the @@ -989,6 +1028,15 @@ func (d *decoder) flowEndSegments(end rdf.Term, in *element) ([]rdf.Term, error) refuse := func(note string) ([]rdf.Term, error) { return nil, &UnsupportedError{What: fmt.Sprintf("the flow end <%s> of <%s>", end.Value, in.iri), Note: note} } + if d.graph.HasProperty(end, rdf.SysML+pDeclaredName) { + return refuse("it declares a name, and the `from`/`to` form writes the end by its reference chain") + } + if d.graph.HasProperty(end, rdf.SysML+pDeclaredShortName) { + return refuse("it declares a short name, and the `from`/`to` form writes the end by its reference chain") + } + if len(d.graph.Objects(end, rdf.SysML+pOwnedAnnotation)) > 0 { + return refuse("it owns annotations, which the `from`/`to` form cannot carry") + } var segments []rdf.Term target, ok, err := d.standardEndTarget(end, in) if err != nil { @@ -1022,9 +1070,125 @@ func (d *decoder) flowEndSegments(end rdf.Term, in *element) ([]rdf.Term, error) if len(redefined) != 1 { return refuse(fmt.Sprintf("its FlowFeature redefines %d features, and a flow end names exactly one", len(redefined))) } + toolkitFeatures := d.toolkitFlowFeatures(end) + if len(toolkitFeatures) > 0 { + if len(toolkitFeatures) != 1 || len(features) != 1 || features[0] != toolkitFeatures[0] { + return refuse(fmt.Sprintf("it owns %d toolkit FlowFeatures, and a flow end writes exactly one reference chain", len(toolkitFeatures))) + } + feature := toolkitFeatures[0] + flowFeature, flowEnd := d.byIRI[feature.Value], d.byIRI[end.Value] + if flowFeature == nil || flowEnd == nil { + return refuse("its FlowFeature is not an implied ReferenceUsage owned through a FeatureMembership") + } + implied, err := d.flowFeatureImplied(flowFeature, flowEnd) + if err != nil { + return nil, err + } + if !implied { + return refuse("its FlowFeature is not an implied ReferenceUsage owned through a FeatureMembership") + } + if d.graph.HasProperty(feature, rdf.SysML+pDeclaredName) || + d.graph.HasProperty(feature, rdf.SysML+pDeclaredShortName) || + len(d.graph.Objects(feature, rdf.SysML+pOwnedAnnotation)) > 0 { + return refuse("its FlowFeature declares a name or annotations that the `from`/`to` form cannot carry") + } + if d.graph.HasProperty(feature, rdf.SysML+pValue) { + return refuse("its FlowFeature carries a value that the `from`/`to` form cannot carry") + } + for _, relation := range d.graph.Objects(feature, rdf.SysML+pOwnedRelationship) { + meta := d.metaclass(relation) + if meta == mRedefinition { + continue + } + if !impliedRelationshipMetaclasses[meta] || !d.graph.BoolValue(relation, rdf.SysML+pIsImplied) { + return refuse(fmt.Sprintf("its FlowFeature owns a %s relationship that the `from`/`to` form cannot carry", meta)) + } + } + if name, hasName := d.graph.Lexical(feature, rdf.SysML+pName); hasName { + redefinedName, err := d.flowEndTargetName(redefined[0]) + if err != nil { + return nil, err + } + if name != redefinedName { + return refuse("its FlowFeature's derived name does not match the feature it redefines") + } + } + for _, relation := range d.graph.Objects(end, rdf.SysML+pOwnedRelationship) { + meta := d.metaclass(relation) + switch { + case meta == mReferenceSubsetting, meta == mFeatureMembership: + case impliedRelationshipMetaclasses[meta] && d.graph.BoolValue(relation, rdf.SysML+pIsImplied): + default: + return refuse(fmt.Sprintf("it owns a %s relationship that the `from`/`to` form cannot carry", meta)) + } + } + if name, hasName := d.graph.Lexical(end, rdf.SysML+pName); hasName { + var endRedefined []rdf.Term + endRedefined = append(endRedefined, d.graph.Objects(end, rdf.SysML+relationshipProperty[ast.RelRedefines])...) + if len(endRedefined) == 0 { + for _, relation := range d.graph.Objects(end, rdf.SysML+pOwnedRelationship) { + if d.metaclass(relation) != mRedefinition { + continue + } + if target, ok := d.graph.Object(relation, rdf.SysML+"redefinedFeature"); ok { + endRedefined = append(endRedefined, target) + } + } + } + if len(endRedefined) != 1 { + return refuse(fmt.Sprintf("its derived name has %d redefined features, and a flow end names exactly one", len(endRedefined))) + } + redefinedName, err := d.flowEndTargetName(endRedefined[0]) + if err != nil { + return nil, err + } + if name != redefinedName { + return refuse("its derived name does not match the feature it redefines") + } + } + } return append(segments, redefined[0]), nil } +func (d *decoder) toolkitFlowFeatures(end rdf.Term) []rdf.Term { + var features []rdf.Term + seen := map[string]bool{} + for _, membership := range d.graph.Objects(end, rdf.SysML+pOwnedFeatureMembership) { + if d.metaclass(membership) != mFeatureMembership { + continue + } + feature, ok := d.graph.Object(membership, rdf.SysML+pMemberElement) + if !ok || d.metaclass(feature) != mReferenceUsage { + continue + } + owning, ok := d.owningMembership[feature.Value] + if !ok || owning.iri != membership.Value || seen[feature.Value] { + continue + } + seen[feature.Value] = true + features = append(features, feature) + } + return features +} + +func (d *decoder) flowEndTargetName(target rdf.Term) (string, error) { + if name, ok := d.graph.Lexical(target, rdf.SysML+pName); ok { + return name, nil + } + if !target.IsIRI() { + return "", &UnsupportedError{What: fmt.Sprintf("the flow-end redefinition target %s", target), Note: "it has no name"} + } + el, err := d.referencedElement(target.Value) + if err != nil { + return "", err + } + segments := identitySegments(el.qname) + if len(segments) == 0 { + return "", &UnsupportedError{What: fmt.Sprintf("the flow-end redefinition target <%s>", target.Value), Note: "it has no qualified name"} + } + return identityName(segments[len(segments)-1]), nil +} + // standardEndName renders an end's declared name and ReferencesKeyword. func (d *decoder) standardEndName(end rdf.Term, in *element) (string, error) { keyword := referencesSymbol diff --git a/internal/translate/export/kinds.go b/internal/translate/export/kinds.go index dca8c925c3..af0b4857e7 100644 --- a/internal/translate/export/kinds.go +++ b/internal/translate/export/kinds.go @@ -172,6 +172,11 @@ func declaredMetaclass(decl ast.Node) string { switch n := decl.(type) { case *ast.Namespace: return "Namespace" + case *ast.Package: + if n.IsLibrary { + return mLibraryPackage + } + return mPackage case *ast.Definition: return definitionMetaclass[n.Kind] case *ast.Usage: diff --git a/internal/translate/export/names.go b/internal/translate/export/names.go index 5d15ccedf8..9034e996cd 100644 --- a/internal/translate/export/names.go +++ b/internal/translate/export/names.go @@ -120,29 +120,59 @@ func chooseNames(name, library string, text []byte, want *wanted, previous *name chains = append(chains, ref) continue } - member, target := e.memberOf(ref), e.writtenTarget(ref) - if alias, ok := memberAliases[member]; ok && alias != "" { - member = alias - } + target := e.writtenTarget(ref) if alias, ok := targetAliases[target]; ok && alias != "" { target = alias } - key := nameKey{member: member, target: target} - if _, ok := want.references[key]; !ok && ref.Within == nil { - // A graph written before the payload was a feature states `of T` - // from the flow itself. - if flow := (nameKey{member: e.fqn[ref.Member], target: key.target}); flow != key { - if _, ok := want.references[flow]; ok { - key = flow + memberGroups := e.memberOfCandidates(ref) + var key nameKey + matched := false + for _, members := range memberGroups { + var matches []nameKey + seen := map[nameKey]bool{} + for _, member := range members { + if alias, ok := memberAliases[member]; ok && alias != "" { + member = alias + } + candidate := nameKey{member: member, target: target} + if _, ok := want.references[candidate]; ok && !seen[candidate] { + matches = append(matches, candidate) + seen[candidate] = true + } + } + if len(matches) > 1 { + return nil, false, &UnsupportedError{ + What: fmt.Sprintf("the reference to %s from %s", target, e.memberOf(ref)), + Note: "the member's qualified name matches multiple graph references, so its spelling cannot be checked unambiguously", } } + if len(matches) == 1 { + key, matched = matches[0], true + break + } } - if _, ok := want.references[key]; ok { + if matched { occurrences[key] = append(occurrences[key], ref) continue } - if as := (segmentKey{member: e.memberOf(ref), name: qualifiedText(ref.QN)}); len(writtenAs[as]) > 0 { - roots[as] = append(roots[as], ref) + rootMatched := false + for _, members := range memberGroups { + for _, member := range members { + if alias, ok := memberAliases[member]; ok && alias != "" { + member = alias + } + as := segmentKey{member: member, name: qualifiedText(ref.QN)} + if len(writtenAs[as]) > 0 { + roots[as] = append(roots[as], ref) + rootMatched = true + break + } + } + if rootMatched { + break + } + } + if rootMatched { continue } misread = append(misread, ref) @@ -150,11 +180,24 @@ func chooseNames(name, library string, text []byte, want *wanted, previous *name // A spelling read as another element is still an occurrence of the reference // written that way, unless every writing of it already read back correctly. for _, ref := range misread { - key, ok := written[nameKey{member: e.memberOf(ref), target: qualifiedText(ref.QN)}] - if !ok || len(occurrences[key]) >= want.references[key].count { - continue + found := false + for _, members := range e.memberOfCandidates(ref) { + for _, member := range members { + if alias, ok := memberAliases[member]; ok && alias != "" { + member = alias + } + key, ok := written[nameKey{member: member, target: qualifiedText(ref.QN)}] + if !ok || len(occurrences[key]) >= want.references[key].count { + continue + } + occurrences[key] = append(occurrences[key], ref) + found = true + break + } + if found { + break + } } - occurrences[key] = append(occurrences[key], ref) } if err := e.checkStarts(want.starts, declared); err != nil { return nil, false, err @@ -260,17 +303,74 @@ func addParserAlias(aliases map[string]string, parsed, identity string) { // declaration itself, or the one whose expression body declares that declaration. func (e *encoder) memberOf(ref resolve.Reference) string { if ref.Within != nil { - return e.fqn[ref.Within] + return e.qualifiedMemberName(ref.Within) + } + if member := e.triggerMembers[ref.Member]; member != "" { + return member } // The type of `flow of T` is the typing of the payload feature the flow // owns, which the graph states it from. if u, ok := ref.Member.(*ast.Usage); ok && u.FlowEnds != nil && u.FlowEnds.PayloadDecl == nil && ref.QN != nil && ast.Node(ref.QN) == u.FlowEnds.Payload { if payload := e.payloadOf(u); payload != nil { - return e.fqn[payload] + return e.qualifiedMemberName(payload) + } + } + return e.qualifiedMemberName(ref.Member) +} + +func (e *encoder) memberOfCandidates(ref resolve.Reference) [][]string { + if ref.Within != nil { + return [][]string{e.memberNameCandidates(ref.Within)} + } + if member := e.triggerMembers[ref.Member]; member != "" { + return [][]string{{member}} + } + if u, ok := ref.Member.(*ast.Usage); ok && u.FlowEnds != nil && u.FlowEnds.PayloadDecl == nil && + ref.QN != nil && ast.Node(ref.QN) == u.FlowEnds.Payload { + if payload := e.payloadOf(u); payload != nil { + return [][]string{e.memberNameCandidates(payload), e.memberNameCandidates(ref.Member)} } } - return e.fqn[ref.Member] + return [][]string{e.memberNameCandidates(ref.Member)} +} + +func (e *encoder) memberNameCandidates(node ast.Node) []string { + qualified, positional := e.qualifiedMemberName(node), e.fqn[node] + if qualified != positional { + return []string{qualified, positional} + } + return []string{qualified} +} + +func (e *encoder) qualifiedMemberName(node ast.Node) string { + fqn := e.fqn[node] + sym := e.ids.declSym[node] + if sym == nil || fqn == "" { + return fqn + } + var chain []*symbols.Symbol + for current := sym; current != nil; { + chain = append(chain, current) + if current.OwnerScope == nil { + break + } + owner := current.OwnerScope.Owner() + if owner == current { + break + } + current = owner + } + segments := identitySegments(fqn) + if len(segments) != len(chain) { + return fqn + } + for i, current := range chain { + if current.EffectiveName() { + segments[len(chain)-1-i] = identitySegment(current.Name) + } + } + return strings.Join(segments, "::") } // writtenKeys indexes the wanted references by the member and the spelling @@ -526,19 +626,38 @@ func respelledOperand(node ast.Node, chosen map[*ast.QualifiedName]string) (ast. // graph names in the body it is written in. func (e *encoder) checkStarts(starts map[string]string, declared map[string]ast.Node) error { for fqn, target := range starts { - initial, ok := declared[fqn].(*ast.InitialNode) - if !ok { + switch initial := declared[fqn].(type) { + case *ast.InitialNode: + if _, reached, ok := e.linked(e.res.InitialSymbol(initial)); ok && reached == target { + continue + } + return &UnsupportedError{ + What: fmt.Sprintf("the initial node %s", fqn), + Note: fmt.Sprintf("`first %s` does not name %s in the body it is written in, so the notation cannot state it", nameText(initial.Name()), target), + } + case *ast.Usage: + if initial.Kind == ast.UsageSuccession && len(initial.ConnectorEnds) == 2 { + if source, ok := initial.ConnectorEnds[0].Target.(*ast.QualifiedName); ok { + if _, reached, ok := e.linked(e.res.EndSymbol(source)); ok { + if reached == target { + continue + } + return &UnsupportedError{ + What: fmt.Sprintf("the initial node %s", fqn), + Note: fmt.Sprintf("`first %s` does not name %s in the body it is written in, so the notation cannot state it", qualifiedText(source), target), + } + } + } + } + default: return &UnsupportedError{ What: fmt.Sprintf("the initial node %s", fqn), Note: "the notation written for it does not read back as an initial node, so its start cannot be checked", } } - if _, reached, ok := e.linked(e.res.InitialSymbol(initial)); ok && reached == target { - continue - } return &UnsupportedError{ What: fmt.Sprintf("the initial node %s", fqn), - Note: fmt.Sprintf("`first %s` does not name %s in the body it is written in, so the notation cannot state it", nameText(initial.Name()), target), + Note: "the notation written for it does not read back as an initial node, so its start cannot be checked", } } return nil diff --git a/internal/translate/export/rdf_in.go b/internal/translate/export/rdf_in.go index baaf34ea57..22b5e8f8a5 100644 --- a/internal/translate/export/rdf_in.go +++ b/internal/translate/export/rdf_in.go @@ -85,6 +85,11 @@ type element struct { // UnsupportedError: a converted file that dropped an element would be worse // than a failed conversion. func ToSysML(graph *rdf.Graph) ([]byte, error) { + return ToSysMLWarn(graph, nil) +} + +// ToSysMLWarn converts a graph to notation and reports non-fatal resolutions. +func ToSysMLWarn(graph *rdf.Graph, warn func(string)) ([]byte, error) { if graph == nil || graph.Len() == 0 { return nil, &UnsupportedError{What: "an empty graph", Note: "nothing to convert"} } @@ -125,10 +130,17 @@ func ToSysML(graph *rdf.Graph) ([]byte, error) { if err := checkValueFlags(graph); err != nil { return nil, err } + warned := map[string]bool{} + report := func(message string) { + if warn != nil && !warned[message] { + warned[message] = true + warn(message) + } + } // The first rendering writes every reference fully qualified; reading it // chooses each the shortest spelling that reaches its element. Later // renderings are re-read the same way until every spelling still does. - first := newDecoder(graph, metaclasses, nil) + first := newDecoder(graph, metaclasses, nil, report) text, roots, err := first.notation() if err != nil { return nil, err @@ -142,7 +154,7 @@ func ToSysML(graph *rdf.Graph) ([]byte, error) { return nil, err } for { - d := newDecoder(graph, metaclasses, names) + d := newDecoder(graph, metaclasses, names, report) if text, _, err = d.notation(); err != nil { return nil, err } @@ -157,27 +169,36 @@ func ToSysML(graph *rdf.Graph) ([]byte, error) { } } -func newDecoder(graph *rdf.Graph, metaclasses map[rdf.Term]string, names *nameChoices) *decoder { +func newDecoder(graph *rdf.Graph, metaclasses map[rdf.Term]string, names *nameChoices, warn func(string)) *decoder { + subjects := graph.Subjects() + meta := func(term rdf.Term) string { return rdf.LocalName(metaclasses[term]) } d := &decoder{ - graph: graph, - metaclasses: metaclasses, - byIRI: map[string]*element{}, - byID: map[string]*element{}, - dupID: map[string]bool{}, - memberships: map[string]membership{}, - owningMembership: map[string]membership{}, - nodeMemberships: map[string]membership{}, - nodeMembership: map[string]bool{}, - expressionNodes: map[string]bool{}, - featureValues: featureValueIndex(graph, metaclasses), - prefixed: map[*element]bool{}, - names: names, - wanted: newWanted(), - demoted: map[*element]bool{}, - demotedExpr: map[string]bool{}, - folded: map[*element]*element{}, - libraryRefs: map[string]*element{}, - } + graph: graph, + metaclasses: metaclasses, + warn: warn, + byIRI: map[string]*element{}, + byID: map[string]*element{}, + dupID: map[string]bool{}, + memberships: map[string]membership{}, + owningMembership: map[string]membership{}, + nodeMemberships: map[string]membership{}, + nodeMembership: map[string]bool{}, + expressionNodes: map[string]bool{}, + featureValues: featureValueIndex(graph, metaclasses, subjects), + portDefinitions: newPortDefinitionIndex(graph, meta, subjects), + referenceSubsettings: referenceSubsettingIndex(graph, meta, subjects), + prefixed: map[*element]bool{}, + names: names, + wanted: newWanted(), + demoted: map[*element]bool{}, + demotedExpr: map[string]bool{}, + folded: map[*element]*element{}, + libraryCatalog: identity.LibraryCatalog(libs.NewModelIndex()), + libraryRefs: map[string]*element{}, + importedMemberships: map[string]*identity.LibraryElement{}, + ambiguousImports: map[string]bool{}, + } + d.indexImportedMemberships(subjects) return d } @@ -433,7 +454,7 @@ func checkCardinality(graph *rdf.Graph) error { // checkValueFlags refuses sysml:isDefault or sysml:isInitial, whatever its value, // on a subject with no sysml:value, since the flags spell a feature value's operator. func checkValueFlags(graph *rdf.Graph) error { - featureValues := featureValueIndex(graph, nil) + featureValues := featureValueIndex(graph, nil, graph.Subjects()) for _, triple := range graph.Triples() { predicate := triple.Predicate.Value if predicate != rdf.SysML+pIsDefault && predicate != rdf.SysML+pIsInitial { @@ -456,7 +477,7 @@ func checkValueFlags(graph *rdf.Graph) error { } // featureValueIndex maps each feature to its typed FeatureValue membership. -func featureValueIndex(graph *rdf.Graph, metaclasses map[rdf.Term]string) map[string]rdf.Term { +func featureValueIndex(graph *rdf.Graph, metaclasses map[rdf.Term]string, subjects []rdf.Term) map[string]rdf.Term { index := map[string]rdf.Term{} classOf := func(subject rdf.Term) string { if metaclasses != nil { @@ -466,22 +487,19 @@ func featureValueIndex(graph *rdf.Graph, metaclasses map[rdf.Term]string) map[st } return strings.TrimPrefix(graph.Type(subject), rdf.SysML) } - for _, subject := range graph.Subjects() { - if classOf(subject) != mFeatureValue { - continue - } - for _, feature := range graph.Objects(subject, rdf.SysML+pFeatureWithValue) { - if feature.IsIRI() { - index[feature.Value] = subject + for _, subject := range subjects { + if classOf(subject) == mFeatureValue { + for _, feature := range graph.Objects(subject, rdf.SysML+pFeatureWithValue) { + if feature.IsIRI() { + index[feature.Value] = subject + } } } - } - for _, feature := range graph.Subjects() { for _, property := range []string{pOwnedMembership, pOwnedRelationship} { - for _, membership := range graph.Objects(feature, rdf.SysML+property) { + for _, membership := range graph.Objects(subject, rdf.SysML+property) { if membership.IsIRI() && classOf(membership) == mFeatureValue { - if _, exists := index[feature.Value]; !exists { - index[feature.Value] = membership + if _, exists := index[subject.Value]; !exists { + index[subject.Value] = membership } } } @@ -680,12 +698,14 @@ type decoder struct { dupID map[string]bool // memberships is keyed by membership IRI, and owningMembership by the IRI of // the member each one owns. - memberships map[string]membership - owningMembership map[string]membership - nodeMemberships map[string]membership - nodeMembership map[string]bool - expressionNodes map[string]bool - featureValues map[string]rdf.Term + memberships map[string]membership + owningMembership map[string]membership + nodeMemberships map[string]membership + nodeMembership map[string]bool + expressionNodes map[string]bool + featureValues map[string]rdf.Term + portDefinitions portDefinitionIndex + referenceSubsettings map[string][]rdf.Term // chainOwned indexes the FeatureChaining elements by the chain feature // each names its owningRelatedElement, built on first lookup. chainOwned map[string][]rdf.Term @@ -719,7 +739,11 @@ type decoder struct { // its notation is read in that document's place. library string // libraryRefs holds the library elements references reached by normative id. - libraryRefs map[string]*element + libraryRefs map[string]*element + libraryCatalog *identity.Catalog + importedMemberships map[string]*identity.LibraryElement + ambiguousImports map[string]bool + warn func(string) // written records where each element landed in this pass's notation, the // members of one ahead of it. written []writing @@ -1274,12 +1298,7 @@ func (d *decoder) referencedElement(iri string) (*element, error) { return target, nil } -// libraryStubs finds the subjects that name a standard library element the -// graph references (sysml:isLibraryElement, and no owner in the graph): they -// are references into the bundled library, not declarations, so they are not -// written back. Each one's qualified name must be the one the library gives its -// id, and a membership one must own such an element; a stub the library does -// not know, or names otherwise, is refused rather than trusted. +// libraryStubs finds references into the bundled library, not declarations. func (d *decoder) libraryStubs() (map[string]bool, error) { stubs := map[string]bool{} for _, subject := range d.graph.Subjects() { @@ -1291,22 +1310,40 @@ func (d *decoder) libraryStubs() (map[string]bool, error) { id = stated } if members := d.graph.Objects(subject, rdf.SysML+pMemberElement); len(members) > 0 { - // A library membership is the owning membership the library gives - // its id, and owns the element the library says it owns. - catalog := identity.LibraryCatalog(libs.NewModelIndex()) + catalog := d.libraryCatalog owned, ok := catalog.OwningMembership(id) + member := members[0] + memberName, memberNameKind, hasMemberName := d.librarySubjectName(member) + if !ok && len(members) == 1 && member.IsIRI() && hasMemberName { + if candidate, found := catalog.ElementNamed(memberName); found && d.libraryMetaclassCompatible(member, candidate) { + owned, ok = candidate, true + if d.warn != nil { + d.warn(fmt.Sprintf("the library membership <%s> has id %q, which the bundled standard library does not have; resolved by its %s %s to the owning membership with id %q", + subject.Value, id, memberNameKind, memberName, candidate.OwningMembershipID)) + } + } + } if !ok { + note := fmt.Sprintf("it is marked sysml:isLibraryElement, but the bundled standard library has no owning membership with id %q", id) + if hasMemberName { + note += fmt.Sprintf(" or member %s %s", memberNameKind, memberName) + } return nil, &UnsupportedError{ What: fmt.Sprintf("the library membership <%s>", subject.Value), - Note: fmt.Sprintf("it is marked sysml:isLibraryElement, but the bundled standard library has no owning membership with id %q", id), + Note: note, } } - member := members[0] memberID := rdf.LocalName(member.Value) if stated, ok := d.graph.Lexical(member, rdf.SysML+pElementID); ok { memberID = stated } - if len(members) != 1 || !member.IsIRI() || !d.graph.BoolValue(member, rdf.SysML+pIsLibraryElement) || memberID != owned.ID { + memberMatches := memberID == owned.ID + if !memberMatches && hasMemberName { + if candidate, found := catalog.ElementNamed(memberName); found { + memberMatches = candidate.ID == owned.ID && d.libraryMetaclassCompatible(member, candidate) + } + } + if len(members) != 1 || !member.IsIRI() || !d.graph.BoolValue(member, rdf.SysML+pIsLibraryElement) || !memberMatches { return nil, &UnsupportedError{ What: fmt.Sprintf("the library membership <%s>", subject.Value), Note: fmt.Sprintf("the bundled standard library gives id %q to the owning membership of %s (id %q), and its memberElement is not that library element", id, owned.FQN, owned.ID), @@ -1317,9 +1354,13 @@ func (d *decoder) libraryStubs() (map[string]bool, error) { } lib, ok := d.libraryElement(subject.Value, id) if !ok { + note := fmt.Sprintf("it is marked sysml:isLibraryElement, but the bundled standard library has no element with id %q", id) + if name, kind, stated := d.librarySubjectName(subject); stated { + note += fmt.Sprintf(" or the stated %s %s", kind, name) + } return nil, &UnsupportedError{ What: fmt.Sprintf("the library element <%s>", subject.Value), - Note: fmt.Sprintf("it is marked sysml:isLibraryElement, but the bundled standard library has no element with id %q", id), + Note: note, } } if stated, ok := d.graph.Lexical(subject, rdf.SysML+pQualifiedName); ok && stated != lib.qname { @@ -1339,10 +1380,14 @@ func (d *decoder) libraryElement(iri, id string) (*element, bool) { if el, ok := d.libraryRefs[iri]; ok { return el, true } - lib, ok := identity.LibraryCatalog(libs.NewModelIndex()).Element(id) + lib, by, name, ok := d.resolveLibraryElement(iri, id) if !ok { return nil, false } + if by != "" && d.warn != nil { + d.warn(fmt.Sprintf("the library element <%s> has id %q, which the bundled standard library does not have; resolved by its %s %s to the element with id %q", + iri, id, by, name, lib.ID)) + } el := &element{iri: iri, qname: lib.FQN, elementID: lib.ID, library: true} if lib.Symbol != nil { el.metaclass = declaredMetaclass(lib.Symbol.Decl) @@ -1354,6 +1399,125 @@ func (d *decoder) libraryElement(iri, id string) (*element, bool) { return el, true } +func (d *decoder) resolveLibraryElement(iri, id string) (*identity.LibraryElement, string, string, bool) { + if d.libraryCatalog == nil { + return nil, "", "", false + } + if lib, ok := d.libraryCatalog.Element(id); ok { + return lib, "", "", d.libraryMetaclassCompatible(rdf.IRI(iri), lib) + } + subject := rdf.IRI(iri) + if name, by, stated := d.librarySubjectName(subject); stated { + if name == "" { + return nil, "", "", false + } + lib, ok := d.libraryCatalog.ElementNamed(name) + if !ok { + lib, ok = d.libraryCatalog.RootNamed(name) + } + if !ok || !d.libraryMetaclassCompatible(subject, lib) { + return nil, "", "", false + } + return lib, by, name, true + } + if lib, ok := d.importedMembershipTarget(iri); ok { + return lib, "qualified name", lib.FQN, true + } + return nil, "", "", false +} + +func (d *decoder) librarySubjectName(subject rdf.Term) (string, string, bool) { + if name, ok := d.graph.Lexical(subject, rdf.SysML+pQualifiedName); ok { + return name, "qualified name", true + } + var names []string + seen := map[string]bool{} + for current := subject; current.IsIRI(); { + if seen[current.Value] { + return "", "", false + } + seen[current.Value] = true + if name, ok := d.graph.Lexical(current, rdf.SysML+pQualifiedName); ok { + return name + qualifiedNameSuffix(names), "name and owners", len(names) > 0 + } + name, ok := d.graph.Lexical(current, rdf.SysML+pDeclaredName) + if !ok || name == "" { + return "", "", false + } + names = append([]string{name}, names...) + current = d.libraryOwner(current) + } + if len(names) == 0 { + return "", "", false + } + return strings.Join(names, "::"), "name and owners", true +} + +func qualifiedNameSuffix(names []string) string { + if len(names) == 0 { + return "" + } + return "::" + strings.Join(names, "::") +} + +func (d *decoder) libraryOwner(subject rdf.Term) rdf.Term { + if owner := firstIRI(d.graph, subject, pOwner, pOwningRelatedElement, pMembershipOwningNamespace, "owningNamespace"); owner.Value != "" { + return owner + } + if relationship := firstIRI(d.graph, subject, pOwningRelationship); relationship.Value != "" { + return firstIRI(d.graph, relationship, pMembershipOwningNamespace, pOwningRelatedElement, pOwner) + } + return rdf.Term{} +} + +func (d *decoder) libraryMetaclassCompatible(subject rdf.Term, lib *identity.LibraryElement) bool { + stated := d.metaclass(subject) + if stated == "" { + return true + } + if lib.Symbol == nil { + return false + } + expected := declaredMetaclass(lib.Symbol.Decl) + return expected != "" && ontology.IsAncestorOrSelf(stated, expected) +} + +func (d *decoder) importedMembershipTarget(iri string) (*identity.LibraryElement, bool) { + if d.ambiguousImports[iri] { + return nil, false + } + target, ok := d.importedMemberships[iri] + return target, ok +} + +func (d *decoder) indexImportedMemberships(subjects []rdf.Term) { + for _, subject := range subjects { + if d.metaclass(subject) != mMembershipImport { + continue + } + membership, ok := d.graph.Object(subject, rdf.SysML+pImportedMembership) + if !ok || !membership.IsIRI() { + continue + } + imported, ok := d.graph.Object(subject, rdf.SysML+pImportedElement) + if !ok || !imported.IsIRI() { + continue + } + candidate, ok := d.libraryCatalog.Element(rdf.LocalName(imported.Value)) + if !ok || !d.libraryMetaclassCompatible(imported, candidate) { + continue + } + if previous := d.importedMemberships[membership.Value]; previous != nil && previous.ID != candidate.ID { + delete(d.importedMemberships, membership.Value) + d.ambiguousImports[membership.Value] = true + continue + } + if !d.ambiguousImports[membership.Value] { + d.importedMemberships[membership.Value] = candidate + } + } +} + // checkMembershipEnds refuses a membership whose end is no element of the graph: // the member would be left out of the output and the edge lost with it. func (d *decoder) checkMembershipEnds() error { @@ -1869,11 +2033,10 @@ func (d *decoder) definitionHead(el *element, kind ast.DefinitionKind) (string, if keyword := d.visibility(el); keyword != "" { words = append(words, keyword) } - if d.boolOf(el, rdf.SysML+"isAbstract") { + if d.boolOf(el, rdf.SysML+"isAbstract") && kind != ast.DefEnumeration { words = append(words, "abstract") } - // An enumeration definition is a variation by what it is, not by a keyword - // (SysML v2 EnumerationDefinition); its isVariation writes nothing back. + // The enumeration grammar has no `abstract` or `variation` prefix. if d.boolOf(el, rdf.SysML+"isVariation") && kind != ast.DefEnumeration { words = append(words, "variation") } @@ -2371,7 +2534,8 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { if hasEnds { // A connector's own multiplicity is its declaration, written ahead of // the ends; after them it would read as the last end's. - declared := multPart != "" || len(words) > declaredAt + declared := multPart != "" || len(words) > declaredAt || + el.metaclass == mSuccession && keyword == usageKeyword(ast.UsageSuccession) if declared && keywordAt < len(words) && words[keywordAt] == "bind" { // SysML's `bind` shorthand declares nothing; `bind [1] a = b` gives the // first end the `[1]`, so the declaration takes the `binding … bind` form. @@ -2664,7 +2828,11 @@ func (d *decoder) importHead(el *element) (string, error) { return "", err } if imported == "" { - return "", d.missing(target, sysmlPrefix+pImportedNamespace, "an import names the namespace or membership it imports") + property := pImportedNamespace + if target.metaclass == mMembershipImport || target.metaclass == mMembershipExpose { + property = pImportedMembership + } + return "", d.missing(target, sysmlPrefix+property, "an import names the namespace or membership it imports") } // `P::*::**` imports the members of P recursively; `P::**` imports P itself // and, recursively, its members. An older graph states the kind of an @@ -2800,6 +2968,19 @@ func (d *decoder) importedName(el *element) (string, error) { } } if len(memberships) == 0 { + if membershipClass { + elements := d.graph.Objects(subject, rdf.SysML+pImportedElement) + if len(elements) > 1 { + return "", &UnsupportedError{ + What: fmt.Sprintf("the import <%s>", el.iri), + Note: fmt.Sprintf("a membership import names one element, and it states %d %s%s values", len(elements), sysmlPrefix, pImportedElement), + } + } + if len(elements) == 1 { + return d.referenceName(elements[0], el) + } + return "", nil + } return d.referenceText(el, rdf.SysML+pImportedNamespace) } term := memberships[0] @@ -3292,6 +3473,11 @@ func (d *decoder) identWords(el *element) []string { // implicit metadata-body name — when the rendering's anonymous index names it, // as the name the member's position reads it as. func (d *decoder) writtenQName(el *element) string { + if el.owner != nil && el.owner.metaclass == mAcceptAction && + d.transitionFeatureKind(el.owner) == "trigger" && + el.owner.owner != nil && el.owner.owner.metaclass == mTransition { + return d.writtenQName(el.owner.owner) + } q := el.qname i := strings.LastIndex(q, "::") if i < 0 || strings.HasPrefix(q[i+len("::"):], "@") { @@ -3501,7 +3687,8 @@ func (d *decoder) bodyChildren(el *element) []*element { payload := d.flowPayload(el) var out []*element for _, child := range el.children { - if child != cross && child != payload && !child.implied && d.metadataSigil(child) != "#" { + headEnd := child.metaclass == mFlowEnd && d.headEnd(child, el) + if child != cross && child != payload && !headEnd && !child.implied && d.metadataSigil(child) != "#" { out = append(out, child) } } diff --git a/internal/translate/export/rdf_in_normative.go b/internal/translate/export/rdf_in_normative.go index 4555977e16..96df00fe83 100644 --- a/internal/translate/export/rdf_in_normative.go +++ b/internal/translate/export/rdf_in_normative.go @@ -26,7 +26,7 @@ func (d *decoder) collapsedTargets(el *element) []rdf.Term { for _, object := range d.graph.Objects(rdf.IRI(el.iri), rdf.SysML+property) { if el.metaclass == mConjugatedPortTyping { if object.IsIRI() { - object = originalPortDefinition(d.graph, d.metaclass, rdf.IRI(el.iri), object) + object = d.portDefinitions.original(d.graph, d.metaclass, rdf.IRI(el.iri), object) } else { object = rdf.String(strings.TrimPrefix(object.Value, "~")) } @@ -125,6 +125,8 @@ func (d *decoder) normativeImplied(el, parent *element) (bool, error) { return true, d.verifyConjugated(el, parent) case parent != nil && parent.metaclass == mTransition: return d.transitionImplied(el, parent) + case parent != nil && parent.metaclass == mFlowEnd: + return d.flowFeatureImplied(el, parent) case d.headEnd(el, parent): return true, nil case el.metaclass == mReferenceUsage: @@ -856,15 +858,24 @@ func (d *decoder) chainLinksOrSelf(term rdf.Term) ([]rdf.Term, error) { return links, nil } -// headEnd reports whether el is an unnamed end a connector owns through an -// EndFeatureMembership: the head writes it (`connect a to b`, `first a then b`). +// headEnd reports whether an end owned through EndFeatureMembership is written +// in the connector or flow head. func (d *decoder) headEnd(el, parent *element) bool { - if parent == nil || !ontology.IsAncestorOrSelf(parent.metaclass, "Connector") || - !d.boolOf(el, rdf.SysML+pIsEnd) || d.graph.HasProperty(rdf.IRI(el.iri), rdf.SysML+pDeclaredName) { + if parent == nil || !d.boolOf(el, rdf.SysML+pIsEnd) { return false } m, owned := d.owningMembership[el.iri] - return owned && d.metaclass(rdf.IRI(m.iri)) == mEndFeatureMembership + if !owned || d.metaclass(rdf.IRI(m.iri)) != mEndFeatureMembership { + return false + } + if el.metaclass == mFlowEnd { + switch parent.metaclass { + case "Flow", "FlowUsage", "SuccessionFlow", "SuccessionFlowUsage": + return true + } + } + return ontology.IsAncestorOrSelf(parent.metaclass, "Connector") && + !d.graph.HasProperty(rdf.IRI(el.iri), rdf.SysML+pDeclaredName) } // transitionImplied classifies a child of a TransitionUsage against the head @@ -896,11 +907,29 @@ func (d *decoder) transitionImplied(el, parent *element) (bool, error) { } return agree(pSource, subject, "source") case el.metaclass == mReferenceUsage && owning == mParameterMembership: - // A parameter's direction defaults to `in`, which the element form - // may leave unstated. direction, stated := d.stringOf(el, rdf.SysML+pDirection) - return (direction == "in" || !stated) && !d.graph.HasProperty(subject, rdf.SysML+pDeclaredName) && - len(d.graph.Objects(subject, rdf.SysML+pOwnedRelationship)) == 0, nil + if (direction != "in" && stated) || d.graph.HasProperty(subject, rdf.SysML+pDeclaredName) || + d.graph.HasProperty(subject, rdf.SysML+pDeclaredShortName) { + return false, nil + } + if len(d.graph.Objects(subject, rdf.SysML+pOwnedRelationship)) == 0 { + return true, nil + } + if parent == nil || parent.metaclass != mTransition { + return false, nil + } + name, ok := d.stringOf(el, rdf.SysML+pName) + if !ok || name != "transitionLinkSource" || len(d.graph.Objects(subject, rdf.SysML+pOwnedAnnotation)) > 0 { + return false, nil + } + for _, relation := range d.graph.Objects(subject, rdf.SysML+pOwnedRelationship) { + if !d.graph.BoolValue(relation, rdf.SysML+pIsImplied) && + !impliedRelationshipMetaclasses[d.metaclass(relation)] { + return false, nil + } + } + return d.graph.HasProperty(rdf.IRI(parent.iri), rdf.SysML+pSource) || + d.graph.HasProperty(rdf.IRI(parent.iri), rdf.SysML+pSourceFeature), nil case el.metaclass == mAcceptAction && owning == mTransitionFeatureMembership: kind, _ := d.graph.Lexical(rdf.IRI(m.iri), rdf.SysML+pKind) if kind != "trigger" { diff --git a/internal/translate/export/rdf_in_toolkit.go b/internal/translate/export/rdf_in_toolkit.go index 85853461d7..cc9edf119b 100644 --- a/internal/translate/export/rdf_in_toolkit.go +++ b/internal/translate/export/rdf_in_toolkit.go @@ -54,24 +54,54 @@ func firstObject(graph *rdf.Graph, subject rdf.Term, properties ...string) rdf.T return rdf.Term{} } -// originalPortDefinition is the PortDefinition a ConjugatedPortTyping's `~P` -// names: its stated portDefinition when that is a definition (the toolkit -// points it at the typing itself), else the conjugate's original. -func originalPortDefinition(graph *rdf.Graph, meta func(rdf.Term) string, typing, conjugated rdf.Term) rdf.Term { +// portDefinitionIndex keeps the graph order of definitions a conjugated type names. +type portDefinitionIndex map[string][]portDefinitionCandidate + +type portDefinitionCandidate struct { + subject rdf.Term + original rdf.Term + definition bool +} + +func newPortDefinitionIndex(graph *rdf.Graph, meta func(rdf.Term) string, subjects []rdf.Term) portDefinitionIndex { + index := portDefinitionIndex{} + for _, subject := range subjects { + conjugatedType := rdf.Term{} + if meta(subject) == mPortConjugation { + conjugatedType = firstIRI(graph, subject, pConjugatedType) + } + conjugatedDefinition := firstIRI(graph, subject, pConjugatedPortDefinition) + if conjugatedType.Value != "" { + index[conjugatedType.Value] = append(index[conjugatedType.Value], portDefinitionCandidate{ + subject: subject, + original: firstIRI(graph, subject, pOriginalPortDefinition, pOriginalType), + definition: conjugatedDefinition == conjugatedType, + }) + } + if conjugatedDefinition.Value != "" && conjugatedDefinition != conjugatedType { + index[conjugatedDefinition.Value] = append(index[conjugatedDefinition.Value], portDefinitionCandidate{ + subject: subject, + definition: true, + }) + } + } + return index +} + +// original is the PortDefinition a ConjugatedPortTyping's `~P` names. +func (index portDefinitionIndex) original(graph *rdf.Graph, meta func(rdf.Term) string, typing, conjugated rdf.Term) rdf.Term { if stated := firstIRI(graph, typing, pPortDefinition); stated.Value != "" && meta(stated) != mConjugatedPortTyping { return stated } if conjugated.Value == "" || meta(conjugated) != mConjugatedPortDefinition { return conjugated } - for _, subject := range graph.Subjects() { - if meta(subject) == mPortConjugation && firstIRI(graph, subject, pConjugatedType) == conjugated { - if original := firstIRI(graph, subject, pOriginalPortDefinition, pOriginalType); original.Value != "" { - return original - } + for _, candidate := range index[conjugated.Value] { + if candidate.original.Value != "" { + return candidate.original } - if firstIRI(graph, subject, pConjugatedPortDefinition) == conjugated { - return subject + if candidate.definition { + return candidate.subject } } if ms := firstIRI(graph, conjugated, pOwningRelationship, pOwningMembership); ms.Value != "" { @@ -249,10 +279,12 @@ func deriveNormativeGraph(graph *rdf.Graph, metaclasses map[rdf.Term]string) (*r if !elementForm { return graph, nil } + portDefinitions := newPortDefinitionIndex(graph, meta, graph.Subjects()) n := &normalizer{ graph: graph, meta: meta, chainIndex: chainIndex, + portDefinitions: portDefinitions, elementForm: elementForm, memberOwner: map[string]rdf.Term{}, memberMembership: map[string]rdf.Term{}, @@ -293,6 +325,7 @@ type normalizer struct { graph *rdf.Graph meta func(rdf.Term) string chainIndex map[string][]rdf.Term + portDefinitions portDefinitionIndex elementForm bool memberOwner map[string]rdf.Term memberMembership map[string]rdf.Term @@ -482,7 +515,7 @@ func (n *normalizer) collapseRelationships() { if m == mConjugatedPortTyping { // The head writes `~P`: the original definition, the conjugate of // which the typing names as its type. - target = originalPortDefinition(graph, meta, subject, target) + target = n.portDefinitions.original(graph, meta, subject, target) graph.Add(owner, rdf.OpenSysMLTerm(xConjugatedTyping), rdf.Bool(true)) } if target.Value == "" { @@ -686,6 +719,9 @@ func (n *normalizer) deriveSuccessionEnds() { if source.Value == "" { graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) } + case source.Value == "" && target.Value != "" && target == next: + graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) + graph.Add(subject, rdf.OpenSysMLTerm(xTargetMember), next) case graph.HasProperty(subject, rdf.SysML+pTargetFeature): case next.Value != "": graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) @@ -720,8 +756,22 @@ func (n *normalizer) successionEnds(subject rdf.Term) (source, target rdf.Term) // feature (or `first` member) before it, which an empty source end sequences // from (SysML v2 1.0 § 7.17.4), and the next, which `then` ahead of it targets. func (n *normalizer) sequencedNeighbours(owner, subject rdf.Term) (previous, next rdf.Term) { + membershipMembers := map[string]bool{} + for _, property := range []string{pOwnedRelationship, pOwnedMembership} { + for _, membership := range n.graph.Objects(owner, rdf.SysML+property) { + if n.meta(membership) != mMembership { + continue + } + if member := firstIRI(n.graph, membership, pMemberElement); member.Value != "" { + membershipMembers[member.Value] = true + } + } + } sequenced := func(t rdf.Term) bool { m := n.meta(t) + if m == "" && membershipMembers[t.Value] { + m = mMembership + } return m != "" && !ontology.IsAncestorOrSelf(m, "Succession") && (m == mMembership || !relationshipLike(m)) } @@ -754,8 +804,14 @@ func (n *normalizer) sequencedNeighbours(owner, subject rdf.Term) (previous, nex // its trailing place is the absence of an index. An owner whose members state // an index keeps it: the order it states is the order it takes. func (n *normalizer) stateMemberIndices() { + subjectsByOwner := make(map[string][]rdf.Term, len(n.ownerMembers)) + for _, subject := range n.graph.Subjects() { + if owner, ok := n.memberOwner[subject.Value]; ok { + subjectsByOwner[owner.Value] = append(subjectsByOwner[owner.Value], subject) + } + } for owner, members := range n.ownerMembers { - all, merged, children, indexed := n.mergedMemberOrder(owner, members) + all, merged, children, indexed := n.mergedMemberOrder(owner, members, subjectsByOwner[owner]) if indexed || sameTerms(all, merged) { continue } @@ -771,17 +827,14 @@ func (n *normalizer) stateMemberIndices() { // mergedMemberOrder is the owner's members in subject order, the same slots // with the positional members in their positional order, the members among // them, and whether one already states an index. -func (n *normalizer) mergedMemberOrder(owner string, members []rdf.Term) (all, merged []rdf.Term, children map[string]bool, indexed bool) { +func (n *normalizer) mergedMemberOrder(owner string, members, subjects []rdf.Term) (all, merged []rdf.Term, children map[string]bool, indexed bool) { positional := map[string]bool{} for _, m := range members { positional[m.Value] = true } children = map[string]bool{} next := 0 - for _, subject := range n.graph.Subjects() { - if o, ok := n.memberOwner[subject.Value]; !ok || o.Value != owner { - continue - } + for _, subject := range subjects { if n.graph.HasProperty(subject, rdf.OpenSysML+xMemberIndex) { return nil, nil, nil, true } @@ -861,6 +914,10 @@ func (n *normalizer) bodiedOwners() map[string]bool { if meta(owner) == mSubaction || meta(memberMembership[member]) == mTransitionFeatureMembership { continue } + if flowMetaclasses[meta(owner)] && meta(rdf.IRI(member)) == mPayloadFeature && + meta(memberMembership[member]) == mFeatureMembership { + continue + } // A transition's `then` succession is its head's target, and the chain // of `first a.b` and its EmptyParameterMembers belong to its head too: // none is a body. @@ -1359,7 +1416,7 @@ func newDefaultDropper(graph *rdf.Graph, meta func(rdf.Term) string, chainIndex membershipOwned: membershipOwnedIn(graph, meta), nodeOwned: nodeOwnedIn(graph, meta), membershipSubjects: membershipSubjectsIn(graph, meta), - backed: backedIn(graph, meta), + backed: backedIn(graph, meta, newPortDefinitionIndex(graph, meta, graph.Subjects())), unresolvedRef: unresolvedRef, unresolvedID: unresolvedID, unresolvedTR: unresolvedTR, @@ -1373,6 +1430,18 @@ func newDefaultDropper(graph *rdf.Graph, meta func(rdf.Term) string, chainIndex // dropped reports whether every triple of the subject is dropped: an element // a membership owns, an implied one, or an unresolved-name annotation. func (d *defaultDropper) dropped(v string) bool { + subject := rdf.IRI(v) + if d.implied[v] && d.meta(subject) == mReferenceSubsetting { + referencing := firstIRI(d.graph, subject, pReferencingFeature, pOwningFeature, pOwningRelatedElement, pOwner) + if d.meta(referencing) == mReferenceUsage && + !d.graph.HasProperty(referencing, rdf.SysML+pReferences) { + return d.membershipOwned[v] || d.unresolvedTR[v] + } + } + if d.implied[v] && d.meta(subject) == mRedefinition && + d.meta(firstIRI(d.graph, subject, pOwningRelatedElement, pOwner)) == mFlowEnd { + return d.membershipOwned[v] || d.unresolvedTR[v] + } return d.membershipOwned[v] || d.implied[v] || d.unresolvedTR[v] } @@ -1396,7 +1465,9 @@ func (d *defaultDropper) impliedIncluded(subject rdf.Term) bool { func (d *defaultDropper) iriObject(triple rdf.Triple) (object rdf.Term, unresolvedName string, keep bool) { object = triple.Object local := rdf.LocalName(triple.Predicate.Value) - if text, segment := d.chainSegment[object.Value]; segment && !structuralProps[local] { + flowEndReference := local == pReferencedFeature && d.meta(triple.Subject) == mReferenceSubsetting && + d.meta(firstIRI(d.graph, triple.Subject, pReferencingFeature, pOwningRelatedElement, pOwner)) == mFlowEnd + if text, segment := d.chainSegment[object.Value]; segment && !structuralProps[local] && !flowEndReference { object = rdf.TypedLiteral(text, rdf.OpenSysML+dtExpression) } // A reference the writer could not resolve becomes the name it wrote, @@ -1533,7 +1604,7 @@ func (d *defaultDropper) compositeByDefault(subject rdf.Term) bool { // A usage nested in a type is composite unless `ref` (SysML // Usage::isComposite); only one elsewhere writes `composite`. owner := firstIRI(graph, firstIRI(graph, subject, pOwningRelationship), pOwningRelatedElement, pOwner) - return ontology.IsAncestorOrSelf(meta(subject), "Usage") && owner.IsIRI() && + return (meta(subject) == "FlowUsage" || ontology.IsAncestorOrSelf(meta(subject), "Usage")) && owner.IsIRI() && ontology.IsAncestorOrSelf(meta(owner), "Type") } @@ -1598,7 +1669,7 @@ func membershipSubjectsIn(graph *rdf.Graph, meta func(rdf.Term) string) map[stri // relationship element carries is a statement. A derived edge unbacked by one // is dropped — the toolkit marks the elements it derives these for with // isImpliedIncluded. -func backedIn(graph *rdf.Graph, meta func(rdf.Term) string) map[string]map[string]bool { +func backedIn(graph *rdf.Graph, meta func(rdf.Term) string, portDefinitions portDefinitionIndex) map[string]map[string]bool { backed := map[string]map[string]bool{} for _, subject := range graph.Subjects() { m := meta(subject) @@ -1618,7 +1689,7 @@ func backedIn(graph *rdf.Graph, meta func(rdf.Term) string) map[string]map[strin for _, object := range graph.Objects(subject, rdf.SysML+end) { if m == mConjugatedPortTyping && object.IsIRI() { // The head writes `~P`; the derived type `~P` is not what it states. - object = originalPortDefinition(graph, meta, subject, object) + object = portDefinitions.original(graph, meta, subject, object) } if backed[owner.Value] == nil { backed[owner.Value] = map[string]bool{} diff --git a/internal/translate/export/rdf_normative_test.go b/internal/translate/export/rdf_normative_test.go index 088d678e6f..94c0211986 100644 --- a/internal/translate/export/rdf_normative_test.go +++ b/internal/translate/export/rdf_normative_test.go @@ -34,6 +34,112 @@ func elmt(name string) rdf.Term { return rdf.IRI("urn:sysmlv2:element:" + name) func meta(graph *rdf.Graph, t rdf.Term) string { return rdf.LocalName(graph.Type(t)) } +func TestDropStatedDefaultsKeepsUncollapsedReferenceSubsetting(t *testing.T) { + graph := rdf.NewGraph() + end := elmt("end") + subsetting := elmt("end__rs") + target := elmt("target") + graph.Add(end, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(mReferenceUsage)) + graph.Add(end, rdf.SysMLTerm("isEnd"), rdf.Bool(true)) + graph.Add(end, rdf.SysMLTerm("isImpliedIncluded"), rdf.Bool(true)) + graph.Add(end, rdf.SysMLTerm(pOwnedReferenceSubsetting), subsetting) + graph.Add(subsetting, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(mReferenceSubsetting)) + graph.Add(subsetting, rdf.SysMLTerm("isImplied"), rdf.Bool(true)) + graph.Add(subsetting, rdf.SysMLTerm("isImpliedIncluded"), rdf.Bool(true)) + graph.Add(subsetting, rdf.SysMLTerm(pReferencingFeature), end) + graph.Add(subsetting, rdf.SysMLTerm(pReferencedFeature), target) + + meta := func(term rdf.Term) string { return rdf.LocalName(graph.Type(term)) } + normalized, err := dropStatedDefaults(graph, meta, true, chainOwnerIndex(graph, meta)) + if err != nil { + t.Fatal(err) + } + if got := normalized.Objects(end, rdf.SysML+pOwnedReferenceSubsetting); len(got) != 1 || got[0] != subsetting { + t.Fatalf("reference usage owns %v, want %s", got, subsetting) + } + if got := normalized.Objects(subsetting, rdf.SysML+pReferencedFeature); len(got) != 1 || got[0] != target { + t.Fatalf("reference subsetting targets %v, want %s", got, target) + } +} + +func TestSuccessionEndsUseExternalMembershipSource(t *testing.T) { + graph := rdf.NewGraph() + owner := elmt("owner") + start := elmt("library-start") + startMembership := elmt("owner__start") + succession := elmt("succession") + successionMembership := elmt("owner__succession") + target := elmt("target") + targetMembership := elmt("owner__target") + sourceEnd := elmt("succession__source") + sourceEndMembership := elmt("succession__source-membership") + targetEnd := elmt("succession__target") + targetEndMembership := elmt("succession__target-membership") + for subject, metaclass := range map[rdf.Term]string{ + owner: "ActionUsage", + startMembership: mMembership, + succession: mSuccession, + successionMembership: mFeatureMembership, + target: "ActionUsage", + targetMembership: mFeatureMembership, + sourceEnd: mReferenceUsage, + sourceEndMembership: mEndFeatureMembership, + targetEnd: mReferenceUsage, + targetEndMembership: mEndFeatureMembership, + } { + graph.Add(subject, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(metaclass)) + } + addMembership := func(membership, parent, member rdf.Term) { + graph.Add(membership, rdf.SysMLTerm(pOwningRelatedElement), parent) + graph.Add(membership, rdf.SysMLTerm(pMemberElement), member) + graph.Add(parent, rdf.SysMLTerm(pOwnedRelationship), membership) + } + addMembership(startMembership, owner, start) + addMembership(successionMembership, owner, succession) + addMembership(targetMembership, owner, target) + addMembership(sourceEndMembership, succession, sourceEnd) + addMembership(targetEndMembership, succession, targetEnd) + graph.Add(targetEnd, rdf.SysMLTerm(pReferences), target) + + meta := func(term rdf.Term) string { return rdf.LocalName(graph.Type(term)) } + n := &normalizer{ + graph: graph, + meta: meta, + memberOwner: map[string]rdf.Term{}, + memberMembership: map[string]rdf.Term{}, + nodeMember: map[string]bool{}, + nodeOwner: map[string]rdf.Term{}, + membershipSubject: map[string]bool{}, + ownerMembers: map[string][]rdf.Term{}, + } + n.indexMemberships() + n.orderMembers() + n.deriveSuccessionEnds() + + if got, ok := graph.Object(succession, rdf.OpenSysML+xSourceMember); !ok || got != start { + t.Fatalf("succession source member %v, want %s", got, start) + } + if got, ok := graph.Object(succession, rdf.OpenSysML+xTargetMember); !ok || got != target { + t.Fatalf("succession target member %v, want %s", got, target) + } +} + +func TestSequencesFromMatchesInitialMembershipReferent(t *testing.T) { + graph := rdf.NewGraph() + membership := elmt("initial-membership") + start := elmt("library-start") + succession := elmt("succession") + graph.Add(membership, rdf.SysMLTerm(pMemberElement), start) + graph.Add(succession, rdf.OpenSysMLTerm(xSourceMember), start) + d := &decoder{graph: graph} + from := &element{iri: membership.Value, metaclass: mMembership, membershipKeyword: "first"} + to := &element{iri: succession.Value, metaclass: mSuccession} + + if !d.sequencesFrom(to, from) { + t.Fatal("succession source does not match the initial membership's referent") + } +} + // jsonValues flattens a single value or an array of values. func jsonValues(v any) []any { if arr, ok := v.([]any); ok { @@ -560,3 +666,122 @@ func TestNormativeImplicitMetadataBodyRedefinition(t *testing.T) { targetEnds: []string{"redefinedFeature", "subsettedFeature", "general"}, }) } + +func TestMembershipImportUsesImportedElementWhenMembershipIsUnavailable(t *testing.T) { + graph := rdf.NewGraph() + imported := elmt("imported") + target := elmt("target") + graph.Add(imported, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(mMembershipImport)) + graph.Add(imported, rdf.SysMLTerm(pImportedElement), target) + graph.Add(target, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(mPackage)) + graph.Add(target, rdf.SysMLTerm(pQualifiedName), rdf.String("Base::DataValue")) + graph.Add(target, rdf.SysMLTerm(pDeclaredName), rdf.String("DataValue")) + + metaclasses, err := checkTypes(graph) + if err != nil { + t.Fatal(err) + } + d := newDecoder(graph, metaclasses, nil, nil) + importElement := &element{iri: imported.Value, metaclass: mMembershipImport} + d.byIRI[target.Value] = &element{ + iri: target.Value, metaclass: mPackage, qname: "Base::DataValue", elementID: "target", + } + name, err := d.importedName(importElement) + if err != nil { + t.Fatal(err) + } + if name != "Base::DataValue" { + t.Fatalf("imported name = %q, want %q", name, "Base::DataValue") + } +} + +func TestReferencesInEffectivelyNamedMembersMatchEitherQualifiedNameForm(t *testing.T) { + const model = `package M { + part def Base { + part spacecraft { + part lm { + part stage { + attribute engineStatus : ScalarValues::String; + } + } + } + } + part def Derived :> Base { + part :>> spacecraft { + part :>> lm { + part :>> stage { + attribute engineStatus : ScalarValues::String; + } + } + } + } +}` + for _, test := range []struct { + name string + qname string + }{ + {name: "positional"}, + {name: "effective", qname: "M::Derived::spacecraft::lm::stage::engineStatus"}, + } { + t.Run(test.name, func(t *testing.T) { + graph := normativeGraph(t, model) + var engineStatus rdf.Term + for _, triple := range graph.Triples() { + if triple.Predicate != rdf.SysMLTerm(pQualifiedName) || !strings.HasPrefix(triple.Object.Value, "M::Derived::") || + !strings.HasSuffix(triple.Object.Value, "::engineStatus") { + continue + } + engineStatus = triple.Subject + break + } + if engineStatus.Value == "" { + t.Fatal("the derived engineStatus has no qualified name") + } + if test.qname != "" { + var triples []rdf.Triple + for _, triple := range graph.Triples() { + if triple.Subject == engineStatus && triple.Predicate == rdf.SysMLTerm(pQualifiedName) { + continue + } + triples = append(triples, triple) + } + graph = rdf.NewGraphOf(triples, graph.Prefixes) + graph.Add(engineStatus, rdf.SysMLTerm(pQualifiedName), rdf.String(test.qname)) + } + + notation, err := ToSysML(graph) + if err != nil { + t.Fatalf("back to notation: %v", err) + } + p := parser.New(source.New("m.sysml", notation)) + p.ParseFile() + if len(p.Diagnostics) > 0 { + t.Fatalf("notation does not parse: %v\n%s", p.Diagnostics, notation) + } + }) + } +} + +func TestFlowEndsRoundTripFromFeatureChains(t *testing.T) { + const model = `package P { + item def Fuel; + port def FuelPort { + in item fuel : Fuel; + } + part def Vessel { + port fuelPort : FuelPort; + } + part source : Vessel; + part target : Vessel; + flow of Fuel from source.fuelPort.fuel to target.fuelPort.fuel; +}` + notation, err := ToSysML(normativeGraph(t, model)) + if err != nil { + t.Fatalf("ToSysML: %v", err) + } + p := parser.New(source.New("flow.sysml", notation)) + p.ParseFile() + if len(p.Diagnostics) > 0 { + t.Fatalf("the decoded flow does not parse: %v\n%s", p.Diagnostics, notation) + } +} diff --git a/internal/translate/export/rdf_out.go b/internal/translate/export/rdf_out.go index 341ddbd0c2..ac0a4a9c52 100644 --- a/internal/translate/export/rdf_out.go +++ b/internal/translate/export/rdf_out.go @@ -77,6 +77,7 @@ const ( pOwnedEndFeature = "ownedEndFeature" pImportedNamespace = "importedNamespace" pImportedMembership = "importedMembership" + pImportedElement = "importedElement" pAliasFor = "aliasedElement" // an older mapping's alias target, read only pMemberName = "memberName" pMemberShortName = "memberShortName" @@ -470,6 +471,7 @@ func newEncoderOver(file *source.SourceFile, root *ast.RootNamespace, form IDFor performed: map[ast.Node]bool{}, effects: map[ast.Node]bool{}, triggerParams: map[ast.Node]string{}, + triggerMembers: map[ast.Node]string{}, payloads: map[*ast.Usage]*ast.Usage{}, payloadFeatures: map[*ast.Usage]bool{}, fqn: map[ast.Node]string{}, @@ -491,6 +493,7 @@ func newEncoderOver(file *source.SourceFile, root *ast.RootNamespace, form IDFor if err := e.collect(root.Members, ""); err != nil { return nil, err } + e.indexTriggerMembers() return e, nil } @@ -523,7 +526,8 @@ type encoder struct { effects map[ast.Node]bool // triggerParams holds the parameters of a transition's trigger action: each // maps to the AcceptActionUsage property that names it, if any. - triggerParams map[ast.Node]string + triggerParams map[ast.Node]string + triggerMembers map[ast.Node]string // payloads holds the PayloadFeature each flow's `of` clause declares, keyed // by the flow: the declared feature of `of p : T`, or one made up for // `of T`, which states only its typing (SysML-textual-bnf PayloadFeature). @@ -564,6 +568,19 @@ type encoder struct { membershipImports []membershipImport } +func (e *encoder) indexTriggerMembers() { + for node, fqn := range e.fqn { + transition, ok := node.(*ast.TransitionMember) + if !ok || transition.Trigger == nil { + continue + } + e.triggerMembers[transition.Trigger] = fqn + if event, ok := transition.Trigger.(*ast.AcceptEvent); ok && event.Payload != nil { + e.triggerMembers[event.Payload] = fqn + } + } +} + // membershipImport is a membership import's subject and the name it imports. type membershipImport struct { subject rdf.Term diff --git a/internal/translate/export/root_namespace.go b/internal/translate/export/root_namespace.go index dab4ce05dc..3c48e14ad5 100644 --- a/internal/translate/export/root_namespace.go +++ b/internal/translate/export/root_namespace.go @@ -117,12 +117,13 @@ func withoutRootNamespace(graph *rdf.Graph) *rdf.Graph { dropped := map[string]bool{} droppedMemberIndexes := map[string]bool{} var indexes []rootIndex - for _, subject := range graph.Subjects() { + subjects := graph.Subjects() + for _, subject := range subjects { if !transparentRootSubject(graph, subject) { continue } dropped[subject.Value] = true - restated, dropIndexes := rootMemberIndexes(graph, rootNamespaceMembers(graph, subject)) + restated, dropIndexes := rootMemberIndexes(graph, rootNamespaceMembers(graph, subject), subjects) indexes = append(indexes, restated...) if dropIndexes { for _, index := range restated { @@ -165,7 +166,7 @@ type rootIndex struct { // wrapper's order is dropped, and whether the indexes the members state are // replaced: none when the members all state one, or state none and appear in // the wrapper's order already. -func rootMemberIndexes(graph *rdf.Graph, members []rdf.Term) ([]rootIndex, bool) { +func rootMemberIndexes(graph *rdf.Graph, members, subjects []rdf.Term) ([]rootIndex, bool) { indexed := 0 listed := make(map[string]bool, len(members)) for _, member := range members { @@ -179,7 +180,7 @@ func rootMemberIndexes(graph *rdf.Graph, members []rdf.Term) ([]rootIndex, bool) return nil, false case indexed > 0: return rootIndexesOf(members), true - case inSubjectOrder(graph, members, listed): + case inSubjectOrder(subjects, members, listed): return nil, false } return rootIndexesOf(members), false @@ -195,9 +196,9 @@ func rootIndexesOf(members []rdf.Term) []rootIndex { // inSubjectOrder reports whether the graph lists the members as subjects in // the given order. -func inSubjectOrder(graph *rdf.Graph, members []rdf.Term, listed map[string]bool) bool { +func inSubjectOrder(subjects, members []rdf.Term, listed map[string]bool) bool { var subjectOrder []rdf.Term - for _, candidate := range graph.Subjects() { + for _, candidate := range subjects { if listed[candidate.Value] { subjectOrder = append(subjectOrder, candidate) } @@ -266,12 +267,12 @@ func unownedElements(graph *rdf.Graph) []rdf.Term { return roots } -// LibraryReference reports whether subject names a standard library element -// (or its owning membership) the graph references rather than declares: marked -// sysml:isLibraryElement, with no owner in the graph. +// LibraryReference reports whether subject names a library element the graph +// references rather than declares: it has no owner or owned relationships. func LibraryReference(graph *rdf.Graph, subject rdf.Term) bool { return graph.BoolValue(subject, rdf.SysML+pIsLibraryElement) && !hasOwner(graph, subject) && - !graph.HasProperty(subject, rdf.SysML+pMembershipOwningNamespace) + !graph.HasProperty(subject, rdf.SysML+pMembershipOwningNamespace) && + !graph.HasProperty(subject, rdf.SysML+pOwnedRelationship) } func hasOwner(graph *rdf.Graph, subject rdf.Term) bool { diff --git a/tests/export/testdata/interchange/README.md b/tests/export/testdata/interchange/README.md new file mode 100644 index 0000000000..3a34a0ad4a --- /dev/null +++ b/tests/export/testdata/interchange/README.md @@ -0,0 +1 @@ +The two library identity JSON fixtures are toolkit v0.10.0 full-JSON exports with a hand-edited `ScalarValues::Real` library stub id; the unmatched case also changes its qualified name. diff --git a/tests/export/testdata/interchange/flow_ends.golden.sysml b/tests/export/testdata/interchange/flow_ends.golden.sysml new file mode 100644 index 0000000000..14184c5721 --- /dev/null +++ b/tests/export/testdata/interchange/flow_ends.golden.sysml @@ -0,0 +1,14 @@ +package FlowEnds { + item def Payload; + part def PayloadHolder { + item payload : Payload; + } + part def Endpoint { + part holder : PayloadHolder; + } + part def Assembly { + part source : Endpoint; + part target : Endpoint; + flow of Payload from source.holder.payload to target.holder.payload; + } +} diff --git a/tests/export/testdata/interchange/flow_ends.sysml b/tests/export/testdata/interchange/flow_ends.sysml new file mode 100644 index 0000000000..14184c5721 --- /dev/null +++ b/tests/export/testdata/interchange/flow_ends.sysml @@ -0,0 +1,14 @@ +package FlowEnds { + item def Payload; + part def PayloadHolder { + item payload : Payload; + } + part def Endpoint { + part holder : PayloadHolder; + } + part def Assembly { + part source : Endpoint; + part target : Endpoint; + flow of Payload from source.holder.payload to target.holder.payload; + } +} diff --git a/tests/export/testdata/interchange/flow_ends.toolkit.full.json b/tests/export/testdata/interchange/flow_ends.toolkit.full.json new file mode 100644 index 0000000000..328c182f82 --- /dev/null +++ b/tests/export/testdata/interchange/flow_ends.toolkit.full.json @@ -0,0 +1,5567 @@ +[ + { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "membership": [ + { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "ownedMembership": [ + { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845" + } + ], + "ownedRelationship": [ + { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5025186b-8d52-5fd7-9866-e0e739184845", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "memberElementId": "2f73b34f-ee68-5e69-9be7-112b48346541", + "memberName": "FlowEnds", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "ownedMemberElementId": "2f73b34f-ee68-5e69-9be7-112b48346541", + "ownedMemberName": "FlowEnds", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + }, + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "shortName": null, + "source": [ + { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + } + ], + "target": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541", + "@type": "Package", + "aliasIds": [], + "declaredName": "FlowEnds", + "declaredShortName": null, + "documentation": [], + "elementId": "2f73b34f-ee68-5e69-9be7-112b48346541", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "membership": [ + { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee" + }, + { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95" + }, + { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d" + }, + { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2" + } + ], + "name": "FlowEnds", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "ownedMembership": [ + { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee" + }, + { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95" + }, + { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d" + }, + { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2" + } + ], + "ownedRelationship": [ + { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee" + }, + { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95" + }, + { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d" + }, + { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2" + } + ], + "owner": { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + }, + "owningMembership": { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845" + }, + "owningNamespace": { + "@id": "4ae5f4fa-4753-5940-8bc4-f27e7dd78232" + }, + "owningRelationship": { + "@id": "5025186b-8d52-5fd7-9866-e0e739184845" + }, + "qualifiedName": "FlowEnds", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f39a586d-6ea7-5289-a541-aca72b00dfee", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "memberElementId": "789f3a8d-d66f-5524-9bed-d370a23d6057", + "memberName": "Payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "ownedMemberElementId": "789f3a8d-d66f-5524-9bed-d370a23d6057", + "ownedMemberName": "Payload", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "target": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057", + "@type": "ItemDefinition", + "aliasIds": [], + "declaredName": "Payload", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "789f3a8d-d66f-5524-9bed-d370a23d6057", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Payload", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "bcacfa78-13f4-5362-9700-604e6cdf5880" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "bcacfa78-13f4-5362-9700-604e6cdf5880" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "bcacfa78-13f4-5362-9700-604e6cdf5880" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningMembership": { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee" + }, + "owningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": { + "@id": "f39a586d-6ea7-5289-a541-aca72b00dfee" + }, + "qualifiedName": "FlowEnds::Payload", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b781643d-a7c1-5947-8d76-b51c4a586d95", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "memberElementId": "88e2d4ca-e276-5187-b44e-4e91cbe01393", + "memberName": "PayloadHolder", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "ownedMemberElementId": "88e2d4ca-e276-5187-b44e-4e91cbe01393", + "ownedMemberName": "PayloadHolder", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "target": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "PayloadHolder", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "88e2d4ca-e276-5187-b44e-4e91cbe01393", + "endFeature": [], + "feature": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "featureMembership": [ + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "membership": [ + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + } + ], + "multiplicity": null, + "name": "PayloadHolder", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedFeatureMembership": [ + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedMember": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedMembership": [ + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + }, + { + "@id": "4485e629-b8b4-5222-947b-12ddf8830613" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "4485e629-b8b4-5222-947b-12ddf8830613" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "4485e629-b8b4-5222-947b-12ddf8830613" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningMembership": { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95" + }, + "owningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": { + "@id": "b781643d-a7c1-5947-8d76-b51c4a586d95" + }, + "qualifiedName": "FlowEnds::PayloadHolder", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "memberElementId": "dc08c950-4f3e-5019-897e-b0c674972092", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "ownedMemberElementId": "dc08c950-4f3e-5019-897e-b0c674972092", + "ownedMemberFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "ownedMemberName": "payload", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningRelationship": null, + "owningType": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "shortName": null, + "source": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "target": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092", + "@type": "ItemUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "payload", + "declaredShortName": null, + "definition": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "dc08c950-4f3e-5019-897e-b0c674972092", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "0d3509c5-30dd-53e9-9b25-f6155f5a34c4" + }, + { + "@id": "687d60b0-fae4-58ed-b4b8-98d6d420a72e" + } + ], + "ownedSpecialization": [ + { + "@id": "0d3509c5-30dd-53e9-9b25-f6155f5a34c4" + }, + { + "@id": "687d60b0-fae4-58ed-b4b8-98d6d420a72e" + } + ], + "ownedSubsetting": [ + { + "@id": "687d60b0-fae4-58ed-b4b8-98d6d420a72e" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "0d3509c5-30dd-53e9-9b25-f6155f5a34c4" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningDefinition": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningFeatureMembership": { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + }, + "owningMembership": { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + }, + "owningNamespace": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningRelationship": { + "@id": "1f62df8a-fd16-55bc-b9d2-363e52ee92ed" + }, + "owningType": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningUsage": null, + "portionKind": null, + "qualifiedName": "FlowEnds::PayloadHolder::payload", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "0d3509c5-30dd-53e9-9b25-f6155f5a34c4", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0d3509c5-30dd-53e9-9b25-f6155f5a34c4", + "general": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "owningRelationship": null, + "owningType": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "shortName": null, + "source": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "specific": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "target": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "textualRepresentation": [], + "type": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "typedFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + }, + { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "9ea0d333-73a4-560d-91e4-21b16e66480d", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "memberElementId": "8824b96c-920c-57be-bec1-17612dd42265", + "memberName": "Endpoint", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "ownedMemberElementId": "8824b96c-920c-57be-bec1-17612dd42265", + "ownedMemberName": "Endpoint", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "target": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Endpoint", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "8824b96c-920c-57be-bec1-17612dd42265", + "endFeature": [], + "feature": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "featureMembership": [ + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "membership": [ + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + } + ], + "multiplicity": null, + "name": "Endpoint", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedFeatureMembership": [ + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedMember": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedMembership": [ + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedPart": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + }, + { + "@id": "a8c5a1e5-67c0-5aa5-928a-530efd34dfd5" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "a8c5a1e5-67c0-5aa5-928a-530efd34dfd5" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "a8c5a1e5-67c0-5aa5-928a-530efd34dfd5" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningMembership": { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d" + }, + "owningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": { + "@id": "9ea0d333-73a4-560d-91e4-21b16e66480d" + }, + "qualifiedName": "FlowEnds::Endpoint", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "052aa3bc-b203-5870-bd70-ac5b239c1de2", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "memberElementId": "0657e80a-e774-57d1-95ca-291849065195", + "memberName": "holder", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "ownedMemberElementId": "0657e80a-e774-57d1-95ca-291849065195", + "ownedMemberFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "ownedMemberName": "holder", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningRelationship": null, + "owningType": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "shortName": null, + "source": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "target": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "holder", + "declaredShortName": null, + "definition": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "0657e80a-e774-57d1-95ca-291849065195", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "holder", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "c0d454b8-a034-5314-a210-1161a8208721" + }, + { + "@id": "11567119-c2d1-58c7-80aa-29c7ac98b2a8" + } + ], + "ownedSpecialization": [ + { + "@id": "c0d454b8-a034-5314-a210-1161a8208721" + }, + { + "@id": "11567119-c2d1-58c7-80aa-29c7ac98b2a8" + } + ], + "ownedSubsetting": [ + { + "@id": "11567119-c2d1-58c7-80aa-29c7ac98b2a8" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "c0d454b8-a034-5314-a210-1161a8208721" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningDefinition": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningFeatureMembership": { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + }, + "owningMembership": { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + }, + "owningNamespace": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningRelationship": { + "@id": "052aa3bc-b203-5870-bd70-ac5b239c1de2" + }, + "owningType": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningUsage": null, + "partDefinition": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "portionKind": null, + "qualifiedName": "FlowEnds::Endpoint::holder", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "c0d454b8-a034-5314-a210-1161a8208721", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c0d454b8-a034-5314-a210-1161a8208721", + "general": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "owningRelationship": null, + "owningType": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "shortName": null, + "source": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "specific": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "target": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "textualRepresentation": [], + "type": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "typedFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + }, + { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "437e849c-6cbc-5304-acf1-e0293ee9d3d2", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "memberElementId": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e", + "memberName": "Assembly", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "ownedMemberElementId": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e", + "ownedMemberName": "Assembly", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + } + ], + "target": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Assembly", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e", + "endFeature": [], + "feature": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "featureMembership": [ + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "membership": [ + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + } + ], + "multiplicity": null, + "name": "Assembly", + "output": [], + "ownedAction": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedFeatureMembership": [ + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + } + ], + "ownedFlow": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "ownedMember": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedMembership": [ + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedPart": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + }, + { + "@id": "6397eac8-403f-509d-abe5-3ece777a7675" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "6397eac8-403f-509d-abe5-3ece777a7675" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "6397eac8-403f-509d-abe5-3ece777a7675" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningMembership": { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2" + }, + "owningNamespace": { + "@id": "2f73b34f-ee68-5e69-9be7-112b48346541" + }, + "owningRelationship": { + "@id": "437e849c-6cbc-5304-acf1-e0293ee9d3d2" + }, + "qualifiedName": "FlowEnds::Assembly", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2be49f7c-139b-5cd0-a3c4-435661647180", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "memberElementId": "59a5136b-e079-55a0-a995-880adb1ac1bf", + "memberName": "source", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "ownedMemberElementId": "59a5136b-e079-55a0-a995-880adb1ac1bf", + "ownedMemberFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "ownedMemberName": "source", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": null, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "shortName": null, + "source": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "target": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "source", + "declaredShortName": null, + "definition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "59a5136b-e079-55a0-a995-880adb1ac1bf", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "source", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "2837a72c-5b5d-569a-8e66-5cc3248bf0ad" + }, + { + "@id": "c1e438d6-9211-5284-871c-32fc65c8e36a" + } + ], + "ownedSpecialization": [ + { + "@id": "2837a72c-5b5d-569a-8e66-5cc3248bf0ad" + }, + { + "@id": "c1e438d6-9211-5284-871c-32fc65c8e36a" + } + ], + "ownedSubsetting": [ + { + "@id": "c1e438d6-9211-5284-871c-32fc65c8e36a" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "2837a72c-5b5d-569a-8e66-5cc3248bf0ad" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningDefinition": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningFeatureMembership": { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + "owningMembership": { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + "owningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": { + "@id": "2be49f7c-139b-5cd0-a3c4-435661647180" + }, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningUsage": null, + "partDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "portionKind": null, + "qualifiedName": "FlowEnds::Assembly::source", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "2837a72c-5b5d-569a-8e66-5cc3248bf0ad", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2837a72c-5b5d-569a-8e66-5cc3248bf0ad", + "general": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "owningRelationship": null, + "owningType": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "shortName": null, + "source": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "specific": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "target": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "textualRepresentation": [], + "type": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "typedFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + }, + { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f43e3665-1994-56f3-a107-8b542d1e2c9b", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "memberElementId": "c23f2a28-1fcc-5c00-b7db-d563f41cc673", + "memberName": "target", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "ownedMemberElementId": "c23f2a28-1fcc-5c00-b7db-d563f41cc673", + "ownedMemberFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "ownedMemberName": "target", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": null, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "shortName": null, + "source": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "target": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "target", + "declaredShortName": null, + "definition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c23f2a28-1fcc-5c00-b7db-d563f41cc673", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "target", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "53bf54ce-104c-5518-86e1-76272a65d6ae" + }, + { + "@id": "97fbba9f-3a69-511e-92ee-80331d5a6fc4" + } + ], + "ownedSpecialization": [ + { + "@id": "53bf54ce-104c-5518-86e1-76272a65d6ae" + }, + { + "@id": "97fbba9f-3a69-511e-92ee-80331d5a6fc4" + } + ], + "ownedSubsetting": [ + { + "@id": "97fbba9f-3a69-511e-92ee-80331d5a6fc4" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "53bf54ce-104c-5518-86e1-76272a65d6ae" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningDefinition": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningFeatureMembership": { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + "owningMembership": { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + "owningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": { + "@id": "f43e3665-1994-56f3-a107-8b542d1e2c9b" + }, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningUsage": null, + "partDefinition": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "portionKind": null, + "qualifiedName": "FlowEnds::Assembly::target", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "53bf54ce-104c-5518-86e1-76272a65d6ae", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "53bf54ce-104c-5518-86e1-76272a65d6ae", + "general": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "owningRelationship": null, + "owningType": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "shortName": null, + "source": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "specific": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "target": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "textualRepresentation": [], + "type": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "typedFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + }, + { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "401c27fd-bb8e-5230-badb-fa4dc1b787cf", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "memberElementId": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "ownedMemberElementId": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f", + "ownedMemberFeature": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": null, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "shortName": null, + "source": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "target": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f", + "@type": "FlowUsage", + "actionDefinition": [], + "aliasIds": [], + "association": [], + "behavior": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f", + "endFeature": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "featureMembership": [ + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + } + ], + "featureTarget": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "featuringType": [], + "flowDefinition": [], + "flowEnd": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "interaction": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "membership": [ + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "ownedEndFeature": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "ownedFeature": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "ownedMembership": [ + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + }, + { + "@id": "10484cac-d0bf-5138-bcc1-721013a119b8" + }, + { + "@id": "e8ca5eaa-7a68-57ee-b32d-7e04fe3654b7" + } + ], + "ownedSpecialization": [ + { + "@id": "10484cac-d0bf-5138-bcc1-721013a119b8" + }, + { + "@id": "e8ca5eaa-7a68-57ee-b32d-7e04fe3654b7" + } + ], + "ownedSubsetting": [ + { + "@id": "10484cac-d0bf-5138-bcc1-721013a119b8" + }, + { + "@id": "e8ca5eaa-7a68-57ee-b32d-7e04fe3654b7" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningDefinition": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningFeatureMembership": { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + }, + "owningMembership": { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + }, + "owningNamespace": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "401c27fd-bb8e-5230-badb-fa4dc1b787cf" + }, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningUsage": null, + "parameter": [], + "payloadFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "payloadType": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "portionKind": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "relatedFeature": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "shortName": null, + "source": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "sourceFeature": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "sourceOutputFeature": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "target": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "targetFeature": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "targetInputFeature": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "609b131c-9bf5-50ab-9984-c7f1bcb270e0", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "memberElementId": "3df85971-f25e-5281-9404-ab6eff3eec08", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "ownedMemberElementId": "3df85971-f25e-5281-9404-ab6eff3eec08", + "ownedMemberFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "ownedMemberName": "payload", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": null, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + ], + "shortName": null, + "source": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "target": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08", + "@type": "PayloadFeature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "3df85971-f25e-5281-9404-ab6eff3eec08", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "ad7b8d3c-5ac8-5802-844c-77beb774ac4f" + }, + { + "@id": "3008d8e5-f6f0-5798-a265-c8fd6da977a3" + } + ], + "ownedSpecialization": [ + { + "@id": "ad7b8d3c-5ac8-5802-844c-77beb774ac4f" + }, + { + "@id": "3008d8e5-f6f0-5798-a265-c8fd6da977a3" + } + ], + "ownedSubsetting": [ + { + "@id": "3008d8e5-f6f0-5798-a265-c8fd6da977a3" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "ad7b8d3c-5ac8-5802-844c-77beb774ac4f" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningFeatureMembership": { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + "owningMembership": { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + "owningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": { + "@id": "609b131c-9bf5-50ab-9984-c7f1bcb270e0" + }, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "unioningType": [] + }, + { + "@id": "ad7b8d3c-5ac8-5802-844c-77beb774ac4f", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ad7b8d3c-5ac8-5802-844c-77beb774ac4f", + "general": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "owningRelationship": null, + "owningType": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "shortName": null, + "source": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + ], + "specific": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "target": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "textualRepresentation": [], + "type": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "typedFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + }, + { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "memberElementId": "bd5a6280-71b6-5c4a-9399-6ef57459975e", + "memberName": "source", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "ownedMemberElementId": "bd5a6280-71b6-5c4a-9399-6ef57459975e", + "ownedMemberFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "ownedMemberName": "source", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": null, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "shortName": null, + "source": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "target": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e", + "@type": "FlowEnd", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "direction": null, + "documentation": [], + "elementId": "bd5a6280-71b6-5c4a-9399-6ef57459975e", + "endFeature": [], + "endOwningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "feature": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "featureMembership": [ + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + } + ], + "featureTarget": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "membership": [ + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + } + ], + "multiplicity": null, + "name": "source", + "output": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "ownedMembership": [ + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + } + ], + "ownedRedefinition": [ + { + "@id": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41" + } + ], + "ownedReferenceSubsetting": { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9" + }, + "ownedRelationship": [ + { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9" + }, + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + }, + { + "@id": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41" + } + ], + "ownedSpecialization": [ + { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9" + }, + { + "@id": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41" + } + ], + "ownedSubsetting": [ + { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9" + }, + { + "@id": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningFeatureMembership": { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + "owningMembership": { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + "owningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": { + "@id": "a1ab72dc-e0f2-573b-a352-2018ccf79ab0" + }, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "unioningType": [] + }, + { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7d11a880-e60b-5e66-a51b-3810d0e0cff9", + "general": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningRelationship": null, + "owningType": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "referencingFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "relatedElement": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "shortName": null, + "source": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "specific": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "subsettedFeature": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "subsettingFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "target": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "textualRepresentation": [] + }, + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "7b585939-0c2e-5e7a-9182-0cf8a5c860df", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [ + { + "@id": "47317a03-0e95-5600-91fc-b524f2b78f13" + }, + { + "@id": "25d5a2ca-1758-5e51-b2de-0b8e5d44b748" + } + ], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "47317a03-0e95-5600-91fc-b524f2b78f13" + }, + { + "@id": "25d5a2ca-1758-5e51-b2de-0b8e5d44b748" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningFeatureMembership": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": { + "@id": "7d11a880-e60b-5e66-a51b-3810d0e0cff9" + }, + "owningType": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "unioningType": [] + }, + { + "@id": "47317a03-0e95-5600-91fc-b524f2b78f13", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "47317a03-0e95-5600-91fc-b524f2b78f13", + "featureChained": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "shortName": null, + "source": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "target": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "textualRepresentation": [] + }, + { + "@id": "25d5a2ca-1758-5e51-b2de-0b8e5d44b748", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "25d5a2ca-1758-5e51-b2de-0b8e5d44b748", + "featureChained": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "shortName": null, + "source": [ + { + "@id": "7b585939-0c2e-5e7a-9182-0cf8a5c860df" + } + ], + "target": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "textualRepresentation": [] + }, + { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "memberElementId": "3fd75470-a311-5891-8691-0f5f275da37e", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "ownedMemberElementId": "3fd75470-a311-5891-8691-0f5f275da37e", + "ownedMemberFeature": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "ownedMemberName": "payload", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningRelationship": null, + "owningType": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "shortName": null, + "source": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "target": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "out", + "documentation": [], + "elementId": "3fd75470-a311-5891-8691-0f5f275da37e", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "8f9988fb-330d-553d-8e70-32e5d2d445f3" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "8f9988fb-330d-553d-8e70-32e5d2d445f3" + } + ], + "ownedSpecialization": [ + { + "@id": "8f9988fb-330d-553d-8e70-32e5d2d445f3" + } + ], + "ownedSubsetting": [ + { + "@id": "8f9988fb-330d-553d-8e70-32e5d2d445f3" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + }, + "owningMembership": { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + }, + "owningNamespace": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningRelationship": { + "@id": "e5622e61-66ba-5c28-a44d-74ccd9c95b9c" + }, + "owningType": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningUsage": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "8f9988fb-330d-553d-8e70-32e5d2d445f3", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8f9988fb-330d-553d-8e70-32e5d2d445f3", + "general": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "owningRelationship": null, + "owningType": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "redefiningFeature": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "relatedElement": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "shortName": null, + "source": [ + { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + } + ], + "specific": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "subsettedFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "subsettingFeature": { + "@id": "3fd75470-a311-5891-8691-0f5f275da37e" + }, + "target": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "textualRepresentation": [] + }, + { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e58709a1-9688-5ecf-ad70-c919c6ccb47a", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "memberElementId": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc", + "memberName": "target", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "ownedMemberElementId": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc", + "ownedMemberFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "ownedMemberName": "target", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": null, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "shortName": null, + "source": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "target": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc", + "@type": "FlowEnd", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "direction": null, + "documentation": [], + "elementId": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc", + "endFeature": [], + "endOwningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "feature": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "featureMembership": [ + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + } + ], + "featureTarget": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "membership": [ + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + } + ], + "multiplicity": null, + "name": "target", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "ownedMembership": [ + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + } + ], + "ownedRedefinition": [ + { + "@id": "ddfe62fe-b152-5113-a52d-44d0f589a27a" + } + ], + "ownedReferenceSubsetting": { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4" + }, + "ownedRelationship": [ + { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4" + }, + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + }, + { + "@id": "ddfe62fe-b152-5113-a52d-44d0f589a27a" + } + ], + "ownedSpecialization": [ + { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4" + }, + { + "@id": "ddfe62fe-b152-5113-a52d-44d0f589a27a" + } + ], + "ownedSubsetting": [ + { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4" + }, + { + "@id": "ddfe62fe-b152-5113-a52d-44d0f589a27a" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningFeatureMembership": { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + }, + "owningMembership": { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + }, + "owningNamespace": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": { + "@id": "e58709a1-9688-5ecf-ad70-c919c6ccb47a" + }, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "unioningType": [] + }, + { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "72196c68-f374-5e9a-bb70-5f5d960632a4", + "general": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningRelationship": null, + "owningType": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "referencingFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "relatedElement": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "shortName": null, + "source": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "specific": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "subsettedFeature": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "subsettingFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "target": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "textualRepresentation": [] + }, + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "f181017e-4d81-5e27-b4f1-9a058bd66a00", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [ + { + "@id": "7832f10f-4e3b-51f2-a566-362e747d89a2" + }, + { + "@id": "96e682ef-5f99-5e44-8f5c-c00c30fb7bbc" + } + ], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "7832f10f-4e3b-51f2-a566-362e747d89a2" + }, + { + "@id": "96e682ef-5f99-5e44-8f5c-c00c30fb7bbc" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningFeatureMembership": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": { + "@id": "72196c68-f374-5e9a-bb70-5f5d960632a4" + }, + "owningType": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "unioningType": [] + }, + { + "@id": "7832f10f-4e3b-51f2-a566-362e747d89a2", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7832f10f-4e3b-51f2-a566-362e747d89a2", + "featureChained": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "shortName": null, + "source": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "target": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "textualRepresentation": [] + }, + { + "@id": "96e682ef-5f99-5e44-8f5c-c00c30fb7bbc", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "96e682ef-5f99-5e44-8f5c-c00c30fb7bbc", + "featureChained": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + }, + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "shortName": null, + "source": [ + { + "@id": "f181017e-4d81-5e27-b4f1-9a058bd66a00" + } + ], + "target": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "textualRepresentation": [] + }, + { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "743dd476-a0ba-5bc5-a645-00725b403b04", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "memberElementId": "c2fc26d0-7472-54cb-976d-303f761f4e2e", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "ownedMemberElementId": "c2fc26d0-7472-54cb-976d-303f761f4e2e", + "ownedMemberFeature": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "ownedMemberName": "payload", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningRelationship": null, + "owningType": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "shortName": null, + "source": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "target": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "in", + "documentation": [], + "elementId": "c2fc26d0-7472-54cb-976d-303f761f4e2e", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "c04198ef-1839-5cfc-9b84-6292f65f8ff2" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "c04198ef-1839-5cfc-9b84-6292f65f8ff2" + } + ], + "ownedSpecialization": [ + { + "@id": "c04198ef-1839-5cfc-9b84-6292f65f8ff2" + } + ], + "ownedSubsetting": [ + { + "@id": "c04198ef-1839-5cfc-9b84-6292f65f8ff2" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + }, + "owningMembership": { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + }, + "owningNamespace": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningRelationship": { + "@id": "743dd476-a0ba-5bc5-a645-00725b403b04" + }, + "owningType": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningUsage": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "c04198ef-1839-5cfc-9b84-6292f65f8ff2", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c04198ef-1839-5cfc-9b84-6292f65f8ff2", + "general": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "owningRelationship": null, + "owningType": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "redefiningFeature": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "relatedElement": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "shortName": null, + "source": [ + { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + } + ], + "specific": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "subsettedFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "subsettingFeature": { + "@id": "c2fc26d0-7472-54cb-976d-303f761f4e2e" + }, + "target": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "textualRepresentation": [] + }, + { + "@id": "bcacfa78-13f4-5362-9700-604e6cdf5880", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "bcacfa78-13f4-5362-9700-604e6cdf5880", + "general": { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "owningRelationship": null, + "owningType": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + } + ], + "shortName": null, + "source": [ + { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + } + ], + "specific": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "subclassifier": { + "@id": "789f3a8d-d66f-5524-9bed-d370a23d6057" + }, + "superclassifier": { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + }, + "target": [ + { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + } + ], + "textualRepresentation": [] + }, + { + "@id": "4485e629-b8b4-5222-947b-12ddf8830613", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4485e629-b8b4-5222-947b-12ddf8830613", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "owningRelationship": null, + "owningType": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + } + ], + "specific": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "subclassifier": { + "@id": "88e2d4ca-e276-5187-b44e-4e91cbe01393" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "687d60b0-fae4-58ed-b4b8-98d6d420a72e", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "687d60b0-fae4-58ed-b4b8-98d6d420a72e", + "general": { + "@id": "f6f04e9e-c8f9-5a8e-8e4b-a4504ca2bf85" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "owningRelationship": null, + "owningType": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + { + "@id": "f6f04e9e-c8f9-5a8e-8e4b-a4504ca2bf85" + } + ], + "shortName": null, + "source": [ + { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + } + ], + "specific": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "subsettedFeature": { + "@id": "f6f04e9e-c8f9-5a8e-8e4b-a4504ca2bf85" + }, + "subsettingFeature": { + "@id": "dc08c950-4f3e-5019-897e-b0c674972092" + }, + "target": [ + { + "@id": "f6f04e9e-c8f9-5a8e-8e4b-a4504ca2bf85" + } + ], + "textualRepresentation": [] + }, + { + "@id": "a8c5a1e5-67c0-5aa5-928a-530efd34dfd5", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a8c5a1e5-67c0-5aa5-928a-530efd34dfd5", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "owningRelationship": null, + "owningType": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + } + ], + "specific": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "subclassifier": { + "@id": "8824b96c-920c-57be-bec1-17612dd42265" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "11567119-c2d1-58c7-80aa-29c7ac98b2a8", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "11567119-c2d1-58c7-80aa-29c7ac98b2a8", + "general": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "owningRelationship": null, + "owningType": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "shortName": null, + "source": [ + { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + } + ], + "specific": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "subsettedFeature": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "subsettingFeature": { + "@id": "0657e80a-e774-57d1-95ca-291849065195" + }, + "target": [ + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "textualRepresentation": [] + }, + { + "@id": "6397eac8-403f-509d-abe5-3ece777a7675", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6397eac8-403f-509d-abe5-3ece777a7675", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "owningRelationship": null, + "owningType": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + } + ], + "specific": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "subclassifier": { + "@id": "448a7ce0-12d8-5486-9aba-133bc5b3ca5e" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "c1e438d6-9211-5284-871c-32fc65c8e36a", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c1e438d6-9211-5284-871c-32fc65c8e36a", + "general": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "owningRelationship": null, + "owningType": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "shortName": null, + "source": [ + { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + } + ], + "specific": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "subsettedFeature": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "subsettingFeature": { + "@id": "59a5136b-e079-55a0-a995-880adb1ac1bf" + }, + "target": [ + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "textualRepresentation": [] + }, + { + "@id": "97fbba9f-3a69-511e-92ee-80331d5a6fc4", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "97fbba9f-3a69-511e-92ee-80331d5a6fc4", + "general": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "owningRelationship": null, + "owningType": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "shortName": null, + "source": [ + { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + } + ], + "specific": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "subsettedFeature": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "subsettingFeature": { + "@id": "c23f2a28-1fcc-5c00-b7db-d563f41cc673" + }, + "target": [ + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "textualRepresentation": [] + }, + { + "@id": "10484cac-d0bf-5138-bcc1-721013a119b8", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "10484cac-d0bf-5138-bcc1-721013a119b8", + "general": { + "@id": "58f4b8ef-ef56-5e97-8def-549155818a37" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": null, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + { + "@id": "58f4b8ef-ef56-5e97-8def-549155818a37" + } + ], + "shortName": null, + "source": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "specific": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "subsettedFeature": { + "@id": "58f4b8ef-ef56-5e97-8def-549155818a37" + }, + "subsettingFeature": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "target": [ + { + "@id": "58f4b8ef-ef56-5e97-8def-549155818a37" + } + ], + "textualRepresentation": [] + }, + { + "@id": "e8ca5eaa-7a68-57ee-b32d-7e04fe3654b7", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e8ca5eaa-7a68-57ee-b32d-7e04fe3654b7", + "general": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "owningRelationship": null, + "owningType": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "shortName": null, + "source": [ + { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + } + ], + "specific": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "subsettedFeature": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "subsettingFeature": { + "@id": "3d1a2f67-df80-57d9-bedc-8a3ef7eda40f" + }, + "target": [ + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "textualRepresentation": [] + }, + { + "@id": "3008d8e5-f6f0-5798-a265-c8fd6da977a3", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3008d8e5-f6f0-5798-a265-c8fd6da977a3", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "owningRelationship": null, + "owningType": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + } + ], + "specific": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "3df85971-f25e-5281-9404-ab6eff3eec08" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6f47b5b3-4c4f-5858-b5f1-ce7e8c438b41", + "general": { + "@id": "9d174cd9-1d36-52f0-9c44-62001ffb9568" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "owningRelationship": null, + "owningType": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "9d174cd9-1d36-52f0-9c44-62001ffb9568" + }, + "redefiningFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "relatedElement": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + { + "@id": "9d174cd9-1d36-52f0-9c44-62001ffb9568" + } + ], + "shortName": null, + "source": [ + { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + } + ], + "specific": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "subsettedFeature": { + "@id": "9d174cd9-1d36-52f0-9c44-62001ffb9568" + }, + "subsettingFeature": { + "@id": "bd5a6280-71b6-5c4a-9399-6ef57459975e" + }, + "target": [ + { + "@id": "9d174cd9-1d36-52f0-9c44-62001ffb9568" + } + ], + "textualRepresentation": [] + }, + { + "@id": "ddfe62fe-b152-5113-a52d-44d0f589a27a", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ddfe62fe-b152-5113-a52d-44d0f589a27a", + "general": { + "@id": "bf43c516-b2fd-59b0-ae53-a534f1289406" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "owningRelationship": null, + "owningType": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "bf43c516-b2fd-59b0-ae53-a534f1289406" + }, + "redefiningFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "relatedElement": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + { + "@id": "bf43c516-b2fd-59b0-ae53-a534f1289406" + } + ], + "shortName": null, + "source": [ + { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + } + ], + "specific": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "subsettedFeature": { + "@id": "bf43c516-b2fd-59b0-ae53-a534f1289406" + }, + "subsettingFeature": { + "@id": "ed0cde77-fb6d-5042-bb84-b266fd8ec6fc" + }, + "target": [ + { + "@id": "bf43c516-b2fd-59b0-ae53-a534f1289406" + } + ], + "textualRepresentation": [] + } +] diff --git a/tests/export/testdata/interchange/library_identity.golden.sysml b/tests/export/testdata/interchange/library_identity.golden.sysml new file mode 100644 index 0000000000..935cd1ab58 --- /dev/null +++ b/tests/export/testdata/interchange/library_identity.golden.sysml @@ -0,0 +1,8 @@ +library package DocumentLibrary { + part def Component; +} +package LibraryIdentity { + part def Sensor { + attribute value : ScalarValues::Real; + } +} diff --git a/tests/export/testdata/interchange/library_identity.sysml b/tests/export/testdata/interchange/library_identity.sysml new file mode 100644 index 0000000000..aae5dd7d6c --- /dev/null +++ b/tests/export/testdata/interchange/library_identity.sysml @@ -0,0 +1,9 @@ +library package DocumentLibrary { + part def Component; +} + +package LibraryIdentity { + part def Sensor { + attribute value : ScalarValues::Real; + } +} diff --git a/tests/export/testdata/interchange/library_identity.toolkit.full.json b/tests/export/testdata/interchange/library_identity.toolkit.full.json new file mode 100644 index 0000000000..56a7bcd4eb --- /dev/null +++ b/tests/export/testdata/interchange/library_identity.toolkit.full.json @@ -0,0 +1,1213 @@ +[ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0b283aaf-8741-5773-8fc2-37322b93f33e", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "membership": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedMembership": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "ownedRelationship": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c9228882-b4f1-54eb-8d02-5a672771bef8", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "memberElementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "memberName": "DocumentLibrary", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "ownedMemberElementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "ownedMemberName": "DocumentLibrary", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "shortName": null, + "source": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + } + ], + "target": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "@type": "LibraryPackage", + "aliasIds": [], + "declaredName": "DocumentLibrary", + "declaredShortName": null, + "documentation": [], + "elementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": true, + "isStandard": false, + "member": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "membership": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "name": "DocumentLibrary", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedMembership": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "ownedRelationship": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "owner": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningMembership": { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + "owningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + "qualifiedName": "DocumentLibrary", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5b090e63-520e-579e-a68f-f1b12e754e56", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": true, + "memberElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "memberElementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "memberName": "Component", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "ownedMemberElementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "ownedMemberName": "Component", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "shortName": null, + "source": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "target": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Component", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": true, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Component", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningMembership": { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + }, + "owningNamespace": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningRelationship": { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + }, + "qualifiedName": "DocumentLibrary::Component", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b5efa11b-9679-580d-8edf-4c50e08db617", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "memberElementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "memberName": "LibraryIdentity", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "ownedMemberElementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "ownedMemberName": "LibraryIdentity", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "shortName": null, + "source": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + } + ], + "target": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "@type": "Package", + "aliasIds": [], + "declaredName": "LibraryIdentity", + "declaredShortName": null, + "documentation": [], + "elementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "membership": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "name": "LibraryIdentity", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedMembership": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "ownedRelationship": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "owner": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningMembership": { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + }, + "owningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + }, + "qualifiedName": "LibraryIdentity", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "memberElementId": "92370943-ff56-5024-adcd-a52ef649993d", + "memberName": "Sensor", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "ownedMemberElementId": "92370943-ff56-5024-adcd-a52ef649993d", + "ownedMemberName": "Sensor", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "shortName": null, + "source": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "target": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Sensor", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "92370943-ff56-5024-adcd-a52ef649993d", + "endFeature": [], + "feature": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "featureMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "membership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "multiplicity": null, + "name": "Sensor", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedFeatureMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningMembership": { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + }, + "owningNamespace": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningRelationship": { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + }, + "qualifiedName": "LibraryIdentity::Sensor", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "memberElementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "memberName": "value", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "ownedMemberElementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "ownedMemberFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "ownedMemberName": "value", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": null, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "shortName": null, + "source": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "target": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "@type": "AttributeUsage", + "aliasIds": [], + "attributeDefinition": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "value", + "declaredShortName": null, + "definition": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "value", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedSpecialization": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedSubsetting": [ + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningDefinition": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningFeatureMembership": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningMembership": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningNamespace": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningUsage": null, + "qualifiedName": "LibraryIdentity::Sensor::value", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe", + "general": { + "@id": "11111111-2222-4333-8444-555555555555" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningRelationship": null, + "owningType": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "shortName": null, + "source": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "specific": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "target": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "textualRepresentation": [], + "type": { + "@id": "11111111-2222-4333-8444-555555555555" + }, + "typedFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + }, + { + "@id": "790265e4-6780-50a7-944d-11edc7255883", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "790265e4-6780-50a7-944d-11edc7255883", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": true, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "owningRelationship": null, + "owningType": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "specific": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "subclassifier": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "022b0a6b-b8b8-541b-a425-0f1a6962802c", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": null, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "specific": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "subclassifier": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningRelationship": null, + "owningType": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "specific": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@type": "DataType", + "@id": "11111111-2222-4333-8444-555555555555", + "elementId": "11111111-2222-4333-8444-555555555555", + "qualifiedName": "ScalarValues::Real", + "isLibraryElement": true + } +] diff --git a/tests/export/testdata/interchange/library_unmatched.toolkit.full.json b/tests/export/testdata/interchange/library_unmatched.toolkit.full.json new file mode 100644 index 0000000000..7fad4c383f --- /dev/null +++ b/tests/export/testdata/interchange/library_unmatched.toolkit.full.json @@ -0,0 +1,1213 @@ +[ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0b283aaf-8741-5773-8fc2-37322b93f33e", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "membership": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedMembership": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "ownedRelationship": [ + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c9228882-b4f1-54eb-8d02-5a672771bef8", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "memberElementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "memberName": "DocumentLibrary", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "ownedMemberElementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "ownedMemberName": "DocumentLibrary", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "shortName": null, + "source": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + } + ], + "target": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "@type": "LibraryPackage", + "aliasIds": [], + "declaredName": "DocumentLibrary", + "declaredShortName": null, + "documentation": [], + "elementId": "dc00aeae-f561-5574-a6d0-3bd7382f31cc", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": true, + "isStandard": false, + "member": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "membership": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "name": "DocumentLibrary", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedMembership": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "ownedRelationship": [ + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + } + ], + "owner": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningMembership": { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + "owningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": { + "@id": "c9228882-b4f1-54eb-8d02-5a672771bef8" + }, + "qualifiedName": "DocumentLibrary", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5b090e63-520e-579e-a68f-f1b12e754e56", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": true, + "memberElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "memberElementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "memberName": "Component", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "ownedMemberElementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "ownedMemberName": "Component", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "shortName": null, + "source": [ + { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + } + ], + "target": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Component", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": true, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Component", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "790265e4-6780-50a7-944d-11edc7255883" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningMembership": { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + }, + "owningNamespace": { + "@id": "dc00aeae-f561-5574-a6d0-3bd7382f31cc" + }, + "owningRelationship": { + "@id": "5b090e63-520e-579e-a68f-f1b12e754e56" + }, + "qualifiedName": "DocumentLibrary::Component", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b5efa11b-9679-580d-8edf-4c50e08db617", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "memberElementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "memberName": "LibraryIdentity", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "ownedMemberElementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "ownedMemberName": "LibraryIdentity", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "shortName": null, + "source": [ + { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + } + ], + "target": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "@type": "Package", + "aliasIds": [], + "declaredName": "LibraryIdentity", + "declaredShortName": null, + "documentation": [], + "elementId": "95eecbfe-3f3f-5d47-9626-8bd842da05bb", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "membership": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "name": "LibraryIdentity", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedMembership": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "ownedRelationship": [ + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + } + ], + "owner": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningMembership": { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + }, + "owningNamespace": { + "@id": "0b283aaf-8741-5773-8fc2-37322b93f33e" + }, + "owningRelationship": { + "@id": "b5efa11b-9679-580d-8edf-4c50e08db617" + }, + "qualifiedName": "LibraryIdentity", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "memberElementId": "92370943-ff56-5024-adcd-a52ef649993d", + "memberName": "Sensor", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "ownedMemberElementId": "92370943-ff56-5024-adcd-a52ef649993d", + "ownedMemberName": "Sensor", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "shortName": null, + "source": [ + { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + } + ], + "target": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Sensor", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "92370943-ff56-5024-adcd-a52ef649993d", + "endFeature": [], + "feature": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "featureMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "membership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "multiplicity": null, + "name": "Sensor", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedFeatureMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedMembership": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningMembership": { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + }, + "owningNamespace": { + "@id": "95eecbfe-3f3f-5d47-9626-8bd842da05bb" + }, + "owningRelationship": { + "@id": "cbed16c1-4e78-5fb0-b866-a266cd8e1cd8" + }, + "qualifiedName": "LibraryIdentity::Sensor", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "memberElementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "memberName": "value", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "ownedMemberElementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "ownedMemberFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "ownedMemberName": "value", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": null, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "shortName": null, + "source": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "target": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "@type": "AttributeUsage", + "aliasIds": [], + "attributeDefinition": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "value", + "declaredShortName": null, + "definition": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "value", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedSpecialization": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedSubsetting": [ + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningDefinition": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningFeatureMembership": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningMembership": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningNamespace": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": { + "@id": "f8091f01-bfaa-586f-a0c4-b7e64dd5889d" + }, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningUsage": null, + "qualifiedName": "LibraryIdentity::Sensor::value", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e87db069-6ca2-5cd9-a4b7-cabfb8d349fe", + "general": { + "@id": "11111111-2222-4333-8444-555555555555" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningRelationship": null, + "owningType": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "shortName": null, + "source": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "specific": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "target": [ + { + "@id": "11111111-2222-4333-8444-555555555555" + } + ], + "textualRepresentation": [], + "type": { + "@id": "11111111-2222-4333-8444-555555555555" + }, + "typedFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + }, + { + "@id": "790265e4-6780-50a7-944d-11edc7255883", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "790265e4-6780-50a7-944d-11edc7255883", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": true, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "owningRelationship": null, + "owningType": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + } + ], + "specific": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "subclassifier": { + "@id": "d1a43b05-3f65-5b8d-afd0-00a3a04e2ca2" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "022b0a6b-b8b8-541b-a425-0f1a6962802c", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "022b0a6b-b8b8-541b-a425-0f1a6962802c", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "owningRelationship": null, + "owningType": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + } + ], + "specific": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "subclassifier": { + "@id": "92370943-ff56-5024-adcd-a52ef649993d" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1f31ddba-9aa8-51bb-824a-8c96aeb2c775", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "owningRelationship": null, + "owningType": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + } + ], + "specific": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "ab4d5ca0-f17f-545b-93e5-4b5b211b9738" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@type": "DataType", + "@id": "11111111-2222-4333-8444-555555555555", + "elementId": "11111111-2222-4333-8444-555555555555", + "qualifiedName": "Missing::MissingType", + "isLibraryElement": true + } +] diff --git a/tests/export/testdata/interchange/successions.golden.sysml b/tests/export/testdata/interchange/successions.golden.sysml new file mode 100644 index 0000000000..8dafbf6bd9 --- /dev/null +++ b/tests/export/testdata/interchange/successions.golden.sysml @@ -0,0 +1,8 @@ +package Successions { + individual part def Timeline; + individual part timeline : Timeline { + timeslice occurrence firstEvent; + succession first firstEvent then secondEvent; + timeslice occurrence secondEvent; + } +} diff --git a/tests/export/testdata/interchange/successions.sysml b/tests/export/testdata/interchange/successions.sysml new file mode 100644 index 0000000000..e59c4873f2 --- /dev/null +++ b/tests/export/testdata/interchange/successions.sysml @@ -0,0 +1,7 @@ +package Successions { + individual part def Timeline; + individual part timeline : Timeline { + timeslice firstEvent; + then timeslice secondEvent; + } +} diff --git a/tests/export/testdata/interchange/successions.toolkit.full.json b/tests/export/testdata/interchange/successions.toolkit.full.json new file mode 100644 index 0000000000..c4bd2655ec --- /dev/null +++ b/tests/export/testdata/interchange/successions.toolkit.full.json @@ -0,0 +1,2652 @@ +[ + { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "172711ad-3d0c-5e10-8ee0-36b402f72d22", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "membership": [ + { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "ownedMembership": [ + { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412" + } + ], + "ownedRelationship": [ + { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2dd36a80-0a37-5c83-b770-2ec83ede5412", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "memberElementId": "55b692bc-4fe1-54fe-841f-f6cef2135ba6", + "memberName": "Successions", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "ownedMemberElementId": "55b692bc-4fe1-54fe-841f-f6cef2135ba6", + "ownedMemberName": "Successions", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + }, + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "shortName": null, + "source": [ + { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + } + ], + "target": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6", + "@type": "Package", + "aliasIds": [], + "declaredName": "Successions", + "declaredShortName": null, + "documentation": [], + "elementId": "55b692bc-4fe1-54fe-841f-f6cef2135ba6", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "membership": [ + { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5" + }, + { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696" + } + ], + "name": "Successions", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "ownedMembership": [ + { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5" + }, + { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696" + } + ], + "ownedRelationship": [ + { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5" + }, + { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696" + } + ], + "owner": { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + }, + "owningMembership": { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412" + }, + "owningNamespace": { + "@id": "172711ad-3d0c-5e10-8ee0-36b402f72d22" + }, + "owningRelationship": { + "@id": "2dd36a80-0a37-5c83-b770-2ec83ede5412" + }, + "qualifiedName": "Successions", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a77674a1-c0a2-5679-8f65-5b25c2a226c5", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "memberElementId": "d4a924a4-1088-5712-8e5a-a922fe36d7d7", + "memberName": "Timeline", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "ownedMemberElementId": "d4a924a4-1088-5712-8e5a-a922fe36d7d7", + "ownedMemberName": "Timeline", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "shortName": null, + "source": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "target": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Timeline", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "d4a924a4-1088-5712-8e5a-a922fe36d7d7", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": true, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Timeline", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "d081c052-541c-5576-ac81-952755752e8a" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "d081c052-541c-5576-ac81-952755752e8a" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "d081c052-541c-5576-ac81-952755752e8a" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningMembership": { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5" + }, + "owningNamespace": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningRelationship": { + "@id": "a77674a1-c0a2-5679-8f65-5b25c2a226c5" + }, + "qualifiedName": "Successions::Timeline", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a63c1782-dfdd-591a-a25b-94852414d696", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "memberElementId": "09d64173-1864-5055-9318-3817001779d6", + "memberName": "timeline", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "ownedMemberElementId": "09d64173-1864-5055-9318-3817001779d6", + "ownedMemberName": "timeline", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "shortName": null, + "source": [ + { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + } + ], + "target": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "09d64173-1864-5055-9318-3817001779d6", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "timeline", + "declaredShortName": null, + "definition": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "09d64173-1864-5055-9318-3817001779d6", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "featureMembership": [ + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + } + ], + "featureTarget": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "mayTimeVary": null, + "member": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "membership": [ + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + } + ], + "multiplicity": null, + "name": "timeline", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "ownedMembership": [ + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "0ae8b9f9-9038-5ba5-b145-f191ab44fc10" + }, + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + }, + { + "@id": "2cf941a4-beef-5706-9d18-2553c35c9618" + } + ], + "ownedSpecialization": [ + { + "@id": "0ae8b9f9-9038-5ba5-b145-f191ab44fc10" + }, + { + "@id": "2cf941a4-beef-5706-9d18-2553c35c9618" + } + ], + "ownedSubsetting": [ + { + "@id": "2cf941a4-beef-5706-9d18-2553c35c9618" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "0ae8b9f9-9038-5ba5-b145-f191ab44fc10" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696" + }, + "owningNamespace": { + "@id": "55b692bc-4fe1-54fe-841f-f6cef2135ba6" + }, + "owningRelationship": { + "@id": "a63c1782-dfdd-591a-a25b-94852414d696" + }, + "owningType": null, + "owningUsage": null, + "partDefinition": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "portionKind": null, + "qualifiedName": "Successions::timeline", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "unioningType": [], + "usage": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "0ae8b9f9-9038-5ba5-b145-f191ab44fc10", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0ae8b9f9-9038-5ba5-b145-f191ab44fc10", + "general": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": null, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "shortName": null, + "source": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "specific": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "target": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "textualRepresentation": [], + "type": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "typedFeature": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + }, + { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "memberElementId": "5a3c317d-800d-5c91-8b78-7bf351c9a148", + "memberName": "firstEvent", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "ownedMemberElementId": "5a3c317d-800d-5c91-8b78-7bf351c9a148", + "ownedMemberFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "ownedMemberName": "firstEvent", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": null, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "shortName": null, + "source": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "target": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148", + "@type": "OccurrenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "firstEvent", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "5a3c317d-800d-5c91-8b78-7bf351c9a148", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "firstEvent", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "29c87237-c8fb-5b5e-bed1-00d556d05cf4" + } + ], + "ownedSpecialization": [ + { + "@id": "29c87237-c8fb-5b5e-bed1-00d556d05cf4" + } + ], + "ownedSubsetting": [ + { + "@id": "29c87237-c8fb-5b5e-bed1-00d556d05cf4" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + "owningMembership": { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + "owningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": { + "@id": "cd6511f1-68a2-57f5-bf83-a16f1f59fe8b" + }, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningUsage": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "portionKind": "timeslice", + "qualifiedName": "Successions::timeline::firstEvent", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0899baa2-fdb7-58a8-81bd-5fc40827c33c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "memberElementId": "851999d9-91dd-5425-a5cb-826dcd67810e", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "ownedMemberElementId": "851999d9-91dd-5425-a5cb-826dcd67810e", + "ownedMemberFeature": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": null, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "shortName": null, + "source": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "target": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e", + "@type": "SuccessionAsUsage", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "851999d9-91dd-5425-a5cb-826dcd67810e", + "endFeature": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "featureMembership": [ + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + } + ], + "featureTarget": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "membership": [ + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "ownedEndFeature": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "ownedFeature": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "ownedMembership": [ + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + }, + { + "@id": "5afb95f7-7e60-5a25-9b29-ccd787783217" + } + ], + "ownedSpecialization": [ + { + "@id": "5afb95f7-7e60-5a25-9b29-ccd787783217" + } + ], + "ownedSubsetting": [ + { + "@id": "5afb95f7-7e60-5a25-9b29-ccd787783217" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + "owningMembership": { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + "owningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "0899baa2-fdb7-58a8-81bd-5fc40827c33c" + }, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningUsage": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "relatedFeature": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "shortName": null, + "source": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "sourceFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "target": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "targetFeature": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "054d8105-a7cc-54ef-bb57-761aa47c036d", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "memberElementId": "49dbef5c-1f16-5f03-a4df-1e96baaf034e", + "memberName": "earlierOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "ownedMemberElementId": "49dbef5c-1f16-5f03-a4df-1e96baaf034e", + "ownedMemberFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "ownedMemberName": "earlierOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningRelationship": null, + "owningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + } + ], + "shortName": null, + "source": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "target": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "49dbef5c-1f16-5f03-a4df-1e96baaf034e", + "endFeature": [], + "endOwningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "earlierOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa" + } + ], + "ownedReferenceSubsetting": { + "@id": "3a54ac9f-23c3-5cd5-a750-0049638b60c2" + }, + "ownedRelationship": [ + { + "@id": "3a54ac9f-23c3-5cd5-a750-0049638b60c2" + }, + { + "@id": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa" + } + ], + "ownedSpecialization": [ + { + "@id": "3a54ac9f-23c3-5cd5-a750-0049638b60c2" + }, + { + "@id": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa" + } + ], + "ownedSubsetting": [ + { + "@id": "3a54ac9f-23c3-5cd5-a750-0049638b60c2" + }, + { + "@id": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + "owningMembership": { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + "owningNamespace": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningRelationship": { + "@id": "054d8105-a7cc-54ef-bb57-761aa47c036d" + }, + "owningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningUsage": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8c8443a2-9938-5340-84b6-d8586b52e01f", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "memberElementId": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650", + "memberName": "laterOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "ownedMemberElementId": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650", + "ownedMemberFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "ownedMemberName": "laterOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningRelationship": null, + "owningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "shortName": null, + "source": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "target": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650", + "endFeature": [], + "endOwningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "laterOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611" + } + ], + "ownedReferenceSubsetting": { + "@id": "d5bef476-90c1-5c21-a93a-155ece4c7b26" + }, + "ownedRelationship": [ + { + "@id": "d5bef476-90c1-5c21-a93a-155ece4c7b26" + }, + { + "@id": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611" + } + ], + "ownedSpecialization": [ + { + "@id": "d5bef476-90c1-5c21-a93a-155ece4c7b26" + }, + { + "@id": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611" + } + ], + "ownedSubsetting": [ + { + "@id": "d5bef476-90c1-5c21-a93a-155ece4c7b26" + }, + { + "@id": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + }, + "owningMembership": { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + }, + "owningNamespace": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningRelationship": { + "@id": "8c8443a2-9938-5340-84b6-d8586b52e01f" + }, + "owningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningUsage": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "550a8492-f4dc-52b4-9271-94a9b1fc1378", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "memberElementId": "d069988a-057d-5930-9836-c5c101d16a52", + "memberName": "secondEvent", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "ownedMemberElementId": "d069988a-057d-5930-9836-c5c101d16a52", + "ownedMemberFeature": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "ownedMemberName": "secondEvent", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": null, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "shortName": null, + "source": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "target": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52", + "@type": "OccurrenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "secondEvent", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "d069988a-057d-5930-9836-c5c101d16a52", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "secondEvent", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "73c23ab4-1824-52c7-b415-a02aebcc5af3" + } + ], + "ownedSpecialization": [ + { + "@id": "73c23ab4-1824-52c7-b415-a02aebcc5af3" + } + ], + "ownedSubsetting": [ + { + "@id": "73c23ab4-1824-52c7-b415-a02aebcc5af3" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + }, + "owningMembership": { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + }, + "owningNamespace": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": { + "@id": "550a8492-f4dc-52b4-9271-94a9b1fc1378" + }, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningUsage": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "portionKind": "timeslice", + "qualifiedName": "Successions::timeline::secondEvent", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d081c052-541c-5576-ac81-952755752e8a", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d081c052-541c-5576-ac81-952755752e8a", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "owningRelationship": null, + "owningType": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + } + ], + "specific": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "subclassifier": { + "@id": "d4a924a4-1088-5712-8e5a-a922fe36d7d7" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "2cf941a4-beef-5706-9d18-2553c35c9618", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2cf941a4-beef-5706-9d18-2553c35c9618", + "general": { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "owningRelationship": null, + "owningType": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + } + ], + "shortName": null, + "source": [ + { + "@id": "09d64173-1864-5055-9318-3817001779d6" + } + ], + "specific": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "subsettedFeature": { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + }, + "subsettingFeature": { + "@id": "09d64173-1864-5055-9318-3817001779d6" + }, + "target": [ + { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + } + ], + "textualRepresentation": [] + }, + { + "@id": "29c87237-c8fb-5b5e-bed1-00d556d05cf4", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "29c87237-c8fb-5b5e-bed1-00d556d05cf4", + "general": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "owningRelationship": null, + "owningType": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "shortName": null, + "source": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "specific": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "subsettedFeature": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "subsettingFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "target": [ + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "textualRepresentation": [] + }, + { + "@id": "5afb95f7-7e60-5a25-9b29-ccd787783217", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5afb95f7-7e60-5a25-9b29-ccd787783217", + "general": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "owningRelationship": null, + "owningType": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "shortName": null, + "source": [ + { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + } + ], + "specific": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "subsettedFeature": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "subsettingFeature": { + "@id": "851999d9-91dd-5425-a5cb-826dcd67810e" + }, + "target": [ + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "3a54ac9f-23c3-5cd5-a750-0049638b60c2", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3a54ac9f-23c3-5cd5-a750-0049638b60c2", + "general": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "owningRelationship": null, + "owningType": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "referencingFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "relatedElement": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "shortName": null, + "source": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + } + ], + "specific": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "subsettedFeature": { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + }, + "subsettingFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "target": [ + { + "@id": "5a3c317d-800d-5c91-8b78-7bf351c9a148" + } + ], + "textualRepresentation": [] + }, + { + "@id": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "df7efa8b-d0c3-5d66-be86-eb35deb2f0fa", + "general": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "owningRelationship": null, + "owningType": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "redefiningFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "relatedElement": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "shortName": null, + "source": [ + { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + } + ], + "specific": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "subsettedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "subsettingFeature": { + "@id": "49dbef5c-1f16-5f03-a4df-1e96baaf034e" + }, + "target": [ + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d5bef476-90c1-5c21-a93a-155ece4c7b26", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d5bef476-90c1-5c21-a93a-155ece4c7b26", + "general": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "owningRelationship": null, + "owningType": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "referencingFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "relatedElement": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "shortName": null, + "source": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "specific": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "subsettedFeature": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "subsettingFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "target": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d068c0d0-08e6-55a8-88e5-cc9b5dd46611", + "general": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "owningRelationship": null, + "owningType": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "redefiningFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "relatedElement": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "shortName": null, + "source": [ + { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + } + ], + "specific": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "subsettedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "subsettingFeature": { + "@id": "c4f12d7e-72e5-5ac1-be3d-a51f9be4b650" + }, + "target": [ + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "textualRepresentation": [] + }, + { + "@id": "73c23ab4-1824-52c7-b415-a02aebcc5af3", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "73c23ab4-1824-52c7-b415-a02aebcc5af3", + "general": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "owningRelationship": null, + "owningType": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "shortName": null, + "source": [ + { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + } + ], + "specific": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "subsettedFeature": { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + }, + "subsettingFeature": { + "@id": "d069988a-057d-5930-9836-c5c101d16a52" + }, + "target": [ + { + "@id": "42cca478-6f8d-5c19-b990-bc4510c8bea7" + } + ], + "textualRepresentation": [] + } +] diff --git a/tests/export/testdata/interchange/transitions.golden.sysml b/tests/export/testdata/interchange/transitions.golden.sysml new file mode 100644 index 0000000000..e2f72f96fb --- /dev/null +++ b/tests/export/testdata/interchange/transitions.golden.sysml @@ -0,0 +1,13 @@ +package TransitionCases { + item def Go; + action def Reset; + attribute ready : ScalarValues::Boolean; + state def Modes { + state x; + state y; + first start then x; + transition triggered first x accept Go then y; + transition guarded first y accept Go if ready then x; + transition effectful first x do action reset : Reset then y; + } +} diff --git a/tests/export/testdata/interchange/transitions.sysml b/tests/export/testdata/interchange/transitions.sysml new file mode 100644 index 0000000000..f660f93fee --- /dev/null +++ b/tests/export/testdata/interchange/transitions.sysml @@ -0,0 +1,15 @@ +package TransitionCases { + item def Go; + action def Reset; + attribute ready : ScalarValues::Boolean; + + state def Modes { + state x; + state y; + + first start then x; + transition triggered first x accept Go then y; + transition guarded first y accept Go if ready then x; + transition effectful first x do action reset : Reset then y; + } +} diff --git a/tests/export/testdata/interchange/transitions.toolkit.full.json b/tests/export/testdata/interchange/transitions.toolkit.full.json new file mode 100644 index 0000000000..91efc7377a --- /dev/null +++ b/tests/export/testdata/interchange/transitions.toolkit.full.json @@ -0,0 +1,12712 @@ +[ + { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "dc519949-f1d0-53f5-a39c-6a245afcc5b1", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "membership": [ + { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "ownedMembership": [ + { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46" + } + ], + "ownedRelationship": [ + { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "40c2274b-72fa-54ff-8e2f-96b809076f46", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "memberElementId": "2804aaa9-4449-549e-b85e-f731b1f46288", + "memberName": "TransitionCases", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "ownedMemberElementId": "2804aaa9-4449-549e-b85e-f731b1f46288", + "ownedMemberName": "TransitionCases", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + }, + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "shortName": null, + "source": [ + { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + } + ], + "target": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288", + "@type": "Package", + "aliasIds": [], + "declaredName": "TransitionCases", + "declaredShortName": null, + "documentation": [], + "elementId": "2804aaa9-4449-549e-b85e-f731b1f46288", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "membership": [ + { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091" + }, + { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af" + }, + { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b" + }, + { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c" + } + ], + "name": "TransitionCases", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "ownedMembership": [ + { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091" + }, + { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af" + }, + { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b" + }, + { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c" + } + ], + "ownedRelationship": [ + { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091" + }, + { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af" + }, + { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b" + }, + { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c" + } + ], + "owner": { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + }, + "owningMembership": { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46" + }, + "owningNamespace": { + "@id": "dc519949-f1d0-53f5-a39c-6a245afcc5b1" + }, + "owningRelationship": { + "@id": "40c2274b-72fa-54ff-8e2f-96b809076f46" + }, + "qualifiedName": "TransitionCases", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "memberElementId": "93867435-c2c2-584f-9288-378804b1674c", + "memberName": "Go", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "ownedMemberElementId": "93867435-c2c2-584f-9288-378804b1674c", + "ownedMemberName": "Go", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "shortName": null, + "source": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "target": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "93867435-c2c2-584f-9288-378804b1674c", + "@type": "ItemDefinition", + "aliasIds": [], + "declaredName": "Go", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "93867435-c2c2-584f-9288-378804b1674c", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Go", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "29481ee0-157c-5855-b953-b9a6d7565474" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "29481ee0-157c-5855-b953-b9a6d7565474" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "29481ee0-157c-5855-b953-b9a6d7565474" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningMembership": { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091" + }, + "owningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": { + "@id": "a19e7003-d9e6-59e9-b0a5-4e1a3e757091" + }, + "qualifiedName": "TransitionCases::Go", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ec1d1419-e4d0-5c01-9912-c8eea72a51af", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "memberElementId": "944239e2-da22-5343-b4d7-73d746f7ef1c", + "memberName": "Reset", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "ownedMemberElementId": "944239e2-da22-5343-b4d7-73d746f7ef1c", + "ownedMemberName": "Reset", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "shortName": null, + "source": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "target": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c", + "@type": "ActionDefinition", + "action": [], + "aliasIds": [], + "declaredName": "Reset", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "944239e2-da22-5343-b4d7-73d746f7ef1c", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Reset", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "a561334d-468f-5227-89f7-443784d7683d" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "a561334d-468f-5227-89f7-443784d7683d" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "a561334d-468f-5227-89f7-443784d7683d" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningMembership": { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af" + }, + "owningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": { + "@id": "ec1d1419-e4d0-5c01-9912-c8eea72a51af" + }, + "parameter": [], + "qualifiedName": "TransitionCases::Reset", + "shortName": null, + "step": [], + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "memberElementId": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d", + "memberName": "ready", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "ownedMemberElementId": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d", + "ownedMemberName": "ready", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "shortName": null, + "source": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "target": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d", + "@type": "AttributeUsage", + "aliasIds": [], + "attributeDefinition": [ + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "ready", + "declaredShortName": null, + "definition": [ + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "ready", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "ceb5469d-f5cd-5c64-b09f-a43760876a65" + }, + { + "@id": "4deaf063-0c81-50f1-8745-aa59e7a351da" + } + ], + "ownedSpecialization": [ + { + "@id": "ceb5469d-f5cd-5c64-b09f-a43760876a65" + }, + { + "@id": "4deaf063-0c81-50f1-8745-aa59e7a351da" + } + ], + "ownedSubsetting": [ + { + "@id": "4deaf063-0c81-50f1-8745-aa59e7a351da" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "ceb5469d-f5cd-5c64-b09f-a43760876a65" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b" + }, + "owningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": { + "@id": "999a6db2-1a16-5d27-a9d3-ca3d88587c7b" + }, + "owningType": null, + "owningUsage": null, + "qualifiedName": "TransitionCases::ready", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "ceb5469d-f5cd-5c64-b09f-a43760876a65", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ceb5469d-f5cd-5c64-b09f-a43760876a65", + "general": { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "owningRelationship": null, + "owningType": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "specific": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "target": [ + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "textualRepresentation": [], + "type": { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + }, + "typedFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + }, + { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cd4445d1-60c6-5668-9847-6a0b6e13224c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "memberElementId": "81fda28a-0183-5937-9618-f3bb94591956", + "memberName": "Modes", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "ownedMemberElementId": "81fda28a-0183-5937-9618-f3bb94591956", + "ownedMemberName": "Modes", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "shortName": null, + "source": [ + { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + } + ], + "target": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956", + "@type": "StateDefinition", + "action": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "aliasIds": [], + "declaredName": "Modes", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "doAction": null, + "documentation": [], + "elementId": "81fda28a-0183-5937-9618-f3bb94591956", + "endFeature": [], + "entryAction": null, + "exitAction": null, + "feature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "featureMembership": [ + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isParallel": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "membership": [ + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + } + ], + "multiplicity": null, + "name": "Modes", + "output": [], + "ownedAction": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedFeatureMembership": [ + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedMembership": [ + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + }, + { + "@id": "7db6375c-342d-53a4-b550-f257260ec578" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "7db6375c-342d-53a4-b550-f257260ec578" + } + ], + "ownedState": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "ownedSubclassification": [ + { + "@id": "7db6375c-342d-53a4-b550-f257260ec578" + } + ], + "ownedTransition": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningMembership": { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c" + }, + "owningNamespace": { + "@id": "2804aaa9-4449-549e-b85e-f731b1f46288" + }, + "owningRelationship": { + "@id": "cd4445d1-60c6-5668-9847-6a0b6e13224c" + }, + "parameter": [], + "qualifiedName": "TransitionCases::Modes", + "shortName": null, + "state": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "step": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "229b1763-542c-555b-83e9-ea24bb283117", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "229b1763-542c-555b-83e9-ea24bb283117", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "memberElementId": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "memberName": "x", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "ownedMemberElementId": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "ownedMemberFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "ownedMemberName": "x", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "@type": "StateUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "x", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "doAction": null, + "documentation": [], + "elementId": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "endFeature": [], + "endOwningType": null, + "entryAction": null, + "exitAction": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isParallel": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "x", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "24dee6d6-1540-5fb0-955c-3f725233a22e" + } + ], + "ownedSpecialization": [ + { + "@id": "24dee6d6-1540-5fb0-955c-3f725233a22e" + } + ], + "ownedSubsetting": [ + { + "@id": "24dee6d6-1540-5fb0-955c-3f725233a22e" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + "owningMembership": { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": { + "@id": "229b1763-542c-555b-83e9-ea24bb283117" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::x", + "shortName": null, + "stateDefinition": [], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f33648d8-6402-558d-99ca-d29eda1c3513", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "memberElementId": "cca4f9b5-be00-50ed-86ee-8b17efab256d", + "memberName": "y", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "ownedMemberElementId": "cca4f9b5-be00-50ed-86ee-8b17efab256d", + "ownedMemberFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "ownedMemberName": "y", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d", + "@type": "StateUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "y", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "doAction": null, + "documentation": [], + "elementId": "cca4f9b5-be00-50ed-86ee-8b17efab256d", + "endFeature": [], + "endOwningType": null, + "entryAction": null, + "exitAction": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isParallel": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "y", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "d54ee9d9-436d-5cf3-80ba-a438743d3523" + } + ], + "ownedSpecialization": [ + { + "@id": "d54ee9d9-436d-5cf3-80ba-a438743d3523" + } + ], + "ownedSubsetting": [ + { + "@id": "d54ee9d9-436d-5cf3-80ba-a438743d3523" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + "owningMembership": { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": { + "@id": "f33648d8-6402-558d-99ca-d29eda1c3513" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::y", + "shortName": null, + "stateDefinition": [], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "840632a5-1a27-5b2f-9a3b-904f15864f3d", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "memberElementId": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "ownedMemberElementId": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b", + "ownedMemberFeature": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b", + "@type": "SuccessionAsUsage", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b", + "endFeature": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "featureMembership": [ + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + } + ], + "featureTarget": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "membership": [ + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "ownedEndFeature": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "ownedFeature": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "ownedMembership": [ + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + }, + { + "@id": "1315343f-a477-5d77-a769-28f2c987ac02" + } + ], + "ownedSpecialization": [ + { + "@id": "1315343f-a477-5d77-a769-28f2c987ac02" + } + ], + "ownedSubsetting": [ + { + "@id": "1315343f-a477-5d77-a769-28f2c987ac02" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + "owningMembership": { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "840632a5-1a27-5b2f-9a3b-904f15864f3d" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "relatedFeature": [ + { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + } + ], + "sourceFeature": { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "targetFeature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "memberElementId": "847c1458-09dd-569f-9f71-c5123904d723", + "memberName": "earlierOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "ownedMemberElementId": "847c1458-09dd-569f-9f71-c5123904d723", + "ownedMemberFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "ownedMemberName": "earlierOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningRelationship": null, + "owningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + } + ], + "shortName": null, + "source": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "target": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + }, + { + "@id": "80f4284e-73b1-589c-ad80-e25f33022e4f" + }, + { + "@id": "d5b4e7df-e644-5f2f-b95e-cf6f1f6c076d" + }, + { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "847c1458-09dd-569f-9f71-c5123904d723", + "endFeature": [], + "endOwningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "earlierOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "65c53ffd-9757-5d1c-ab82-ae033445a662" + } + ], + "ownedReferenceSubsetting": { + "@id": "5edf40ca-6f32-5807-bf00-dc27f33be09b" + }, + "ownedRelationship": [ + { + "@id": "5edf40ca-6f32-5807-bf00-dc27f33be09b" + }, + { + "@id": "65c53ffd-9757-5d1c-ab82-ae033445a662" + } + ], + "ownedSpecialization": [ + { + "@id": "5edf40ca-6f32-5807-bf00-dc27f33be09b" + }, + { + "@id": "65c53ffd-9757-5d1c-ab82-ae033445a662" + } + ], + "ownedSubsetting": [ + { + "@id": "5edf40ca-6f32-5807-bf00-dc27f33be09b" + }, + { + "@id": "65c53ffd-9757-5d1c-ab82-ae033445a662" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + "owningMembership": { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + "owningNamespace": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningRelationship": { + "@id": "dad9cb72-dbb7-51b7-add7-f0d8b1ac65cd" + }, + "owningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningUsage": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + }, + { + "@id": "80f4284e-73b1-589c-ad80-e25f33022e4f" + }, + { + "@id": "d5b4e7df-e644-5f2f-b95e-cf6f1f6c076d" + }, + { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "5edf40ca-6f32-5807-bf00-dc27f33be09b", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5edf40ca-6f32-5807-bf00-dc27f33be09b", + "general": { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "owningRelationship": null, + "owningType": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + "referencingFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "relatedElement": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + } + ], + "shortName": null, + "source": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + } + ], + "specific": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "subsettedFeature": { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + }, + "subsettingFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "target": [ + { + "@id": "4f9ef3e3-7e26-56a4-b523-6d0684968a5d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "fe7b337d-bd02-5603-9522-028f51724737", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "fe7b337d-bd02-5603-9522-028f51724737", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "memberElementId": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf", + "memberName": "laterOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "ownedMemberElementId": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf", + "ownedMemberFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "ownedMemberName": "laterOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningRelationship": null, + "owningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "shortName": null, + "source": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "target": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf", + "endFeature": [], + "endOwningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "laterOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "b18447d7-0dff-5bf2-b387-00cef2636883" + } + ], + "ownedReferenceSubsetting": { + "@id": "c2ef2684-3aa4-5077-877b-be60380d7948" + }, + "ownedRelationship": [ + { + "@id": "c2ef2684-3aa4-5077-877b-be60380d7948" + }, + { + "@id": "b18447d7-0dff-5bf2-b387-00cef2636883" + } + ], + "ownedSpecialization": [ + { + "@id": "c2ef2684-3aa4-5077-877b-be60380d7948" + }, + { + "@id": "b18447d7-0dff-5bf2-b387-00cef2636883" + } + ], + "ownedSubsetting": [ + { + "@id": "c2ef2684-3aa4-5077-877b-be60380d7948" + }, + { + "@id": "b18447d7-0dff-5bf2-b387-00cef2636883" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + }, + "owningMembership": { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + }, + "owningNamespace": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningRelationship": { + "@id": "fe7b337d-bd02-5603-9522-028f51724737" + }, + "owningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningUsage": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "c2ef2684-3aa4-5077-877b-be60380d7948", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c2ef2684-3aa4-5077-877b-be60380d7948", + "general": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "owningRelationship": null, + "owningType": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "referencingFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "relatedElement": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "specific": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "subsettedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "subsettingFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [] + }, + { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8c205049-d9e4-575a-be8f-6644af654b5b", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "memberElementId": "f913e1e6-2fdf-57eb-b628-967530fecfb5", + "memberName": "triggered", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "ownedMemberElementId": "f913e1e6-2fdf-57eb-b628-967530fecfb5", + "ownedMemberFeature": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "ownedMemberName": "triggered", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5", + "@type": "TransitionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "triggered", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "directedUsage": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "direction": null, + "documentation": [], + "effectAction": [], + "elementId": "f913e1e6-2fdf-57eb-b628-967530fecfb5", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "featureMembership": [ + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + } + ], + "featureTarget": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "featuringType": [], + "guardExpression": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "membership": [ + { + "@id": "cf344e9a-c723-55bb-ace5-8ae07759f54a" + }, + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e" + } + ], + "multiplicity": null, + "name": "triggered", + "nestedAction": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "ownedMembership": [ + { + "@id": "cf344e9a-c723-55bb-ace5-8ae07759f54a" + }, + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "cf344e9a-c723-55bb-ace5-8ae07759f54a" + }, + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e" + }, + { + "@id": "691fb9b1-3d99-53aa-b53a-b9cc1f3760a5" + } + ], + "ownedSpecialization": [ + { + "@id": "691fb9b1-3d99-53aa-b53a-b9cc1f3760a5" + } + ], + "ownedSubsetting": [ + { + "@id": "691fb9b1-3d99-53aa-b53a-b9cc1f3760a5" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + "owningMembership": { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": { + "@id": "8c205049-d9e4-575a-be8f-6644af654b5b" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "parameter": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::triggered", + "shortName": null, + "source": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "succession": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "target": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "textualRepresentation": [], + "triggerAction": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "cf344e9a-c723-55bb-ace5-8ae07759f54a", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cf344e9a-c723-55bb-ace5-8ae07759f54a", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "memberElementId": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "memberName": "x", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "aca69b86-06f1-5658-90b4-b46c32734405", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "memberElementId": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "ownedMemberElementId": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28", + "ownedMemberFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "ownedMemberName": "transitionLinkSource", + "ownedMemberParameter": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": null, + "owningType": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "shortName": null, + "source": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "target": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "in", + "documentation": [], + "elementId": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "transitionLinkSource", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "eeda4c5c-673e-5581-af35-b2f8442a490f" + }, + { + "@id": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5" + } + ], + "ownedSpecialization": [ + { + "@id": "eeda4c5c-673e-5581-af35-b2f8442a490f" + }, + { + "@id": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5" + } + ], + "ownedSubsetting": [ + { + "@id": "eeda4c5c-673e-5581-af35-b2f8442a490f" + }, + { + "@id": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + "owningMembership": { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + "owningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": { + "@id": "aca69b86-06f1-5658-90b4-b46c32734405" + }, + "owningType": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningUsage": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "qualifiedName": "TransitionCases::Modes::triggered::transitionLinkSource", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361", + "@type": "TransitionFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "fade24b6-075f-5ae3-a451-d9bf40661361", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "kind": "trigger", + "memberElement": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "memberElementId": "f6935a96-bd19-51cd-844b-2a22150106bc", + "memberName": "accepter", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "ownedMemberElementId": "f6935a96-bd19-51cd-844b-2a22150106bc", + "ownedMemberFeature": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "ownedMemberName": "accepter", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": null, + "owningType": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "shortName": null, + "source": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "target": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "textualRepresentation": [], + "transitionFeature": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "visibility": "public" + }, + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc", + "@type": "AcceptActionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "directedUsage": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "direction": null, + "documentation": [], + "elementId": "f6935a96-bd19-51cd-844b-2a22150106bc", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "featureMembership": [ + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + } + ], + "featureTarget": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "membership": [ + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + } + ], + "multiplicity": null, + "name": "accepter", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "ownedMembership": [ + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + }, + { + "@id": "8ae173ab-9735-512f-9341-10bed354c9d6" + } + ], + "ownedSpecialization": [ + { + "@id": "8ae173ab-9735-512f-9341-10bed354c9d6" + } + ], + "ownedSubsetting": [ + { + "@id": "8ae173ab-9735-512f-9341-10bed354c9d6" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + "owningMembership": { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + "owningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": { + "@id": "fade24b6-075f-5ae3-a451-d9bf40661361" + }, + "owningType": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningUsage": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "parameter": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "payloadArgument": null, + "payloadParameter": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::triggered::accepter", + "receiverArgument": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "423271e9-8f4a-587e-bf0b-12abbcde6d1b", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "memberElementId": "14a059af-4d3b-5a44-8cb9-f48028c36af9", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "ownedMemberElementId": "14a059af-4d3b-5a44-8cb9-f48028c36af9", + "ownedMemberFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "ownedMemberName": "payload", + "ownedMemberParameter": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningRelationship": null, + "owningType": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "shortName": null, + "source": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "target": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "inout", + "documentation": [], + "elementId": "14a059af-4d3b-5a44-8cb9-f48028c36af9", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "3548912e-7dd4-52f5-bfc9-acef23f01b9f" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "47ce379b-9a90-5ca6-8bb1-b21955575fdc" + }, + { + "@id": "7f30f3e7-5ea2-5518-9ad4-3cc03f55446d" + }, + { + "@id": "3548912e-7dd4-52f5-bfc9-acef23f01b9f" + } + ], + "ownedSpecialization": [ + { + "@id": "47ce379b-9a90-5ca6-8bb1-b21955575fdc" + }, + { + "@id": "7f30f3e7-5ea2-5518-9ad4-3cc03f55446d" + }, + { + "@id": "3548912e-7dd4-52f5-bfc9-acef23f01b9f" + } + ], + "ownedSubsetting": [ + { + "@id": "7f30f3e7-5ea2-5518-9ad4-3cc03f55446d" + }, + { + "@id": "3548912e-7dd4-52f5-bfc9-acef23f01b9f" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "47ce379b-9a90-5ca6-8bb1-b21955575fdc" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + }, + "owningMembership": { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + }, + "owningNamespace": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningRelationship": { + "@id": "423271e9-8f4a-587e-bf0b-12abbcde6d1b" + }, + "owningType": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningUsage": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "qualifiedName": "TransitionCases::Modes::triggered::accepter::payload", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "47ce379b-9a90-5ca6-8bb1-b21955575fdc", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "47ce379b-9a90-5ca6-8bb1-b21955575fdc", + "general": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningRelationship": null, + "owningType": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "shortName": null, + "source": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "specific": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "target": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "textualRepresentation": [], + "type": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "typedFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + }, + { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "da002308-6d84-57d9-ac77-aa73e2533d7e", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "memberElementId": "84b85b32-2e9a-5718-bb6a-428ab490d1de", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "ownedMemberElementId": "84b85b32-2e9a-5718-bb6a-428ab490d1de", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "shortName": null, + "source": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "target": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de", + "@type": "SuccessionAsUsage", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "84b85b32-2e9a-5718-bb6a-428ab490d1de", + "endFeature": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "featureMembership": [ + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + } + ], + "featureTarget": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "membership": [ + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "ownedEndFeature": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "ownedFeature": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "ownedMembership": [ + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + }, + { + "@id": "324ee4f2-385a-5d20-8fbe-a2b3594ae77b" + } + ], + "ownedSpecialization": [ + { + "@id": "324ee4f2-385a-5d20-8fbe-a2b3594ae77b" + } + ], + "ownedSubsetting": [ + { + "@id": "324ee4f2-385a-5d20-8fbe-a2b3594ae77b" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e" + }, + "owningNamespace": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "da002308-6d84-57d9-ac77-aa73e2533d7e" + }, + "owningType": null, + "owningUsage": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "relatedFeature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "sourceFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "targetFeature": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f8720fef-526e-5254-9df6-afa8ae85d8d4", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "memberElementId": "99957371-03b3-5a8c-892c-a3bef51b298c", + "memberName": "earlierOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "ownedMemberElementId": "99957371-03b3-5a8c-892c-a3bef51b298c", + "ownedMemberFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "ownedMemberName": "earlierOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningRelationship": null, + "owningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + } + ], + "shortName": null, + "source": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "target": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "99957371-03b3-5a8c-892c-a3bef51b298c", + "endFeature": [], + "endOwningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "earlierOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "d627471b-a3f9-5d6b-bb0b-d458e748936c" + } + ], + "ownedReferenceSubsetting": { + "@id": "bc019a85-a7bf-5648-8587-a6a06cb56812" + }, + "ownedRelationship": [ + { + "@id": "bc019a85-a7bf-5648-8587-a6a06cb56812" + }, + { + "@id": "d627471b-a3f9-5d6b-bb0b-d458e748936c" + } + ], + "ownedSpecialization": [ + { + "@id": "bc019a85-a7bf-5648-8587-a6a06cb56812" + }, + { + "@id": "d627471b-a3f9-5d6b-bb0b-d458e748936c" + } + ], + "ownedSubsetting": [ + { + "@id": "bc019a85-a7bf-5648-8587-a6a06cb56812" + }, + { + "@id": "d627471b-a3f9-5d6b-bb0b-d458e748936c" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + "owningMembership": { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + "owningNamespace": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningRelationship": { + "@id": "f8720fef-526e-5254-9df6-afa8ae85d8d4" + }, + "owningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningUsage": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "memberElementId": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f", + "memberName": "laterOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "ownedMemberElementId": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f", + "ownedMemberFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "ownedMemberName": "laterOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningRelationship": null, + "owningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "shortName": null, + "source": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "target": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f", + "endFeature": [], + "endOwningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "laterOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "1eae1db4-3568-5414-8023-f35ab74d5c1e" + } + ], + "ownedReferenceSubsetting": { + "@id": "12b54611-a6ce-5a86-b2f8-50e687e4afe1" + }, + "ownedRelationship": [ + { + "@id": "12b54611-a6ce-5a86-b2f8-50e687e4afe1" + }, + { + "@id": "1eae1db4-3568-5414-8023-f35ab74d5c1e" + } + ], + "ownedSpecialization": [ + { + "@id": "12b54611-a6ce-5a86-b2f8-50e687e4afe1" + }, + { + "@id": "1eae1db4-3568-5414-8023-f35ab74d5c1e" + } + ], + "ownedSubsetting": [ + { + "@id": "12b54611-a6ce-5a86-b2f8-50e687e4afe1" + }, + { + "@id": "1eae1db4-3568-5414-8023-f35ab74d5c1e" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + }, + "owningMembership": { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + }, + "owningNamespace": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningRelationship": { + "@id": "d8b9642d-77d6-5fb1-96b3-85a090ff2f57" + }, + "owningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningUsage": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "12b54611-a6ce-5a86-b2f8-50e687e4afe1", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "12b54611-a6ce-5a86-b2f8-50e687e4afe1", + "general": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "owningRelationship": null, + "owningType": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "referencingFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "relatedElement": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "specific": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "subsettedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "subsettingFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "bcf38b49-bc08-5a51-a3ec-d22746acba64", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "memberElementId": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee", + "memberName": "guarded", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "ownedMemberElementId": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee", + "ownedMemberFeature": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "ownedMemberName": "guarded", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee", + "@type": "TransitionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "guarded", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "directedUsage": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "direction": null, + "documentation": [], + "effectAction": [], + "elementId": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "featureMembership": [ + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + } + ], + "featureTarget": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "featuringType": [], + "guardExpression": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "membership": [ + { + "@id": "f4d8dbe5-5add-523b-ba04-806d861fcdbf" + }, + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931" + } + ], + "multiplicity": null, + "name": "guarded", + "nestedAction": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "ownedMembership": [ + { + "@id": "f4d8dbe5-5add-523b-ba04-806d861fcdbf" + }, + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "f4d8dbe5-5add-523b-ba04-806d861fcdbf" + }, + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931" + }, + { + "@id": "957cb8ea-92cc-5244-a909-fafdccd08c8c" + } + ], + "ownedSpecialization": [ + { + "@id": "957cb8ea-92cc-5244-a909-fafdccd08c8c" + } + ], + "ownedSubsetting": [ + { + "@id": "957cb8ea-92cc-5244-a909-fafdccd08c8c" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + "owningMembership": { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": { + "@id": "bcf38b49-bc08-5a51-a3ec-d22746acba64" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "parameter": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::guarded", + "shortName": null, + "source": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "succession": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "target": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "textualRepresentation": [], + "triggerAction": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f4d8dbe5-5add-523b-ba04-806d861fcdbf", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f4d8dbe5-5add-523b-ba04-806d861fcdbf", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "memberElementId": "cca4f9b5-be00-50ed-86ee-8b17efab256d", + "memberName": "y", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "memberElementId": "85a278ad-aed1-54ec-be04-11e9f72daa5a", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "ownedMemberElementId": "85a278ad-aed1-54ec-be04-11e9f72daa5a", + "ownedMemberFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "ownedMemberName": "transitionLinkSource", + "ownedMemberParameter": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "target": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "in", + "documentation": [], + "elementId": "85a278ad-aed1-54ec-be04-11e9f72daa5a", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "transitionLinkSource", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "20539639-4f71-5bee-81d5-ccc04b72bb08" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "8cc6b285-b341-5e87-b1de-dc954e0f18c4" + }, + { + "@id": "20539639-4f71-5bee-81d5-ccc04b72bb08" + } + ], + "ownedSpecialization": [ + { + "@id": "8cc6b285-b341-5e87-b1de-dc954e0f18c4" + }, + { + "@id": "20539639-4f71-5bee-81d5-ccc04b72bb08" + } + ], + "ownedSubsetting": [ + { + "@id": "8cc6b285-b341-5e87-b1de-dc954e0f18c4" + }, + { + "@id": "20539639-4f71-5bee-81d5-ccc04b72bb08" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + "owningMembership": { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + "owningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": { + "@id": "6d22d6a8-e734-5e31-b4fb-19fcf6c96140" + }, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningUsage": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "qualifiedName": "TransitionCases::Modes::guarded::transitionLinkSource", + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a", + "@type": "TransitionFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6f069f5e-0260-5ece-b258-087e743c541a", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "kind": "trigger", + "memberElement": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "memberElementId": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac", + "memberName": "accepter", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "ownedMemberElementId": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac", + "ownedMemberFeature": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "ownedMemberName": "accepter", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "target": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "textualRepresentation": [], + "transitionFeature": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "visibility": "public" + }, + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac", + "@type": "AcceptActionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "directedUsage": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "direction": null, + "documentation": [], + "elementId": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "featureMembership": [ + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + } + ], + "featureTarget": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "membership": [ + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + } + ], + "multiplicity": null, + "name": "accepter", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "ownedMembership": [ + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + }, + { + "@id": "cd462f79-ba27-5a3a-9c17-5ce1566a11a1" + } + ], + "ownedSpecialization": [ + { + "@id": "cd462f79-ba27-5a3a-9c17-5ce1566a11a1" + } + ], + "ownedSubsetting": [ + { + "@id": "cd462f79-ba27-5a3a-9c17-5ce1566a11a1" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + "owningMembership": { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + "owningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": { + "@id": "6f069f5e-0260-5ece-b258-087e743c541a" + }, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningUsage": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "parameter": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "payloadArgument": null, + "payloadParameter": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::guarded::accepter", + "receiverArgument": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682", + "@type": "ParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0fe9103d-8440-5c26-affb-3575f74e9682", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "memberElementId": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a", + "memberName": "payload", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "ownedMemberElementId": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a", + "ownedMemberFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "ownedMemberName": "payload", + "ownedMemberParameter": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningRelationship": null, + "owningType": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "shortName": null, + "source": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "target": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": "inout", + "documentation": [], + "elementId": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "payload", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "24bec017-4527-55fd-85b1-d9e6e5072f81" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "2a67f9da-5213-513b-a38c-3b8d1c8e0e03" + }, + { + "@id": "232484ae-2333-5e06-a1ff-0d64215a4466" + }, + { + "@id": "24bec017-4527-55fd-85b1-d9e6e5072f81" + } + ], + "ownedSpecialization": [ + { + "@id": "2a67f9da-5213-513b-a38c-3b8d1c8e0e03" + }, + { + "@id": "232484ae-2333-5e06-a1ff-0d64215a4466" + }, + { + "@id": "24bec017-4527-55fd-85b1-d9e6e5072f81" + } + ], + "ownedSubsetting": [ + { + "@id": "232484ae-2333-5e06-a1ff-0d64215a4466" + }, + { + "@id": "24bec017-4527-55fd-85b1-d9e6e5072f81" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "2a67f9da-5213-513b-a38c-3b8d1c8e0e03" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + }, + "owningMembership": { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + }, + "owningNamespace": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningRelationship": { + "@id": "0fe9103d-8440-5c26-affb-3575f74e9682" + }, + "owningType": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningUsage": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "qualifiedName": "TransitionCases::Modes::guarded::accepter::payload", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "2a67f9da-5213-513b-a38c-3b8d1c8e0e03", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2a67f9da-5213-513b-a38c-3b8d1c8e0e03", + "general": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningRelationship": null, + "owningType": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "shortName": null, + "source": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "specific": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "target": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "textualRepresentation": [], + "type": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "typedFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + }, + { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953", + "@type": "TransitionFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f58c3057-4717-5e8c-8dc9-7d7d1a344953", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "kind": "guard", + "memberElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "memberElementId": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "ownedMemberElementId": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac", + "ownedMemberFeature": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "target": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "textualRepresentation": [], + "transitionFeature": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "visibility": "public" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac", + "@type": "FeatureReferenceExpression", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "direction": null, + "documentation": [], + "elementId": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "featureMembership": [ + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + } + ], + "featureTarget": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": true, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "membership": [ + { + "@id": "3775fda6-b905-5204-8e9f-cc599637316c" + }, + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8" + } + ], + "multiplicity": null, + "name": null, + "output": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "ownedMembership": [ + { + "@id": "3775fda6-b905-5204-8e9f-cc599637316c" + }, + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "3775fda6-b905-5204-8e9f-cc599637316c" + }, + { + "@id": "876777a1-4824-58f7-867b-09c917a39882" + }, + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8" + } + ], + "ownedSpecialization": [ + { + "@id": "876777a1-4824-58f7-867b-09c917a39882" + } + ], + "ownedSubsetting": [ + { + "@id": "876777a1-4824-58f7-867b-09c917a39882" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningFeatureMembership": { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + "owningMembership": { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + "owningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": { + "@id": "f58c3057-4717-5e8c-8dc9-7d7d1a344953" + }, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "parameter": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "qualifiedName": null, + "referent": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "result": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "3775fda6-b905-5204-8e9f-cc599637316c", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3775fda6-b905-5204-8e9f-cc599637316c", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "memberElementId": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d", + "memberName": "ready", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "shortName": null, + "source": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "target": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "29c386df-d73a-5b63-b021-3138bc7bf931", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "memberElementId": "a5bbd945-f7d2-52da-89e1-87636e299f51", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "ownedMemberElementId": "a5bbd945-f7d2-52da-89e1-87636e299f51", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "target": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51", + "@type": "SuccessionAsUsage", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "a5bbd945-f7d2-52da-89e1-87636e299f51", + "endFeature": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "featureMembership": [ + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + } + ], + "featureTarget": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "membership": [ + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "ownedEndFeature": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "ownedFeature": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "ownedMembership": [ + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + }, + { + "@id": "8c125c6f-8f73-5a01-8125-fcf3aa26c89a" + } + ], + "ownedSpecialization": [ + { + "@id": "8c125c6f-8f73-5a01-8125-fcf3aa26c89a" + } + ], + "ownedSubsetting": [ + { + "@id": "8c125c6f-8f73-5a01-8125-fcf3aa26c89a" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931" + }, + "owningNamespace": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "29c386df-d73a-5b63-b021-3138bc7bf931" + }, + "owningType": null, + "owningUsage": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "relatedFeature": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "sourceFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "targetFeature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d312acc6-fff4-59cc-9d02-8dca3d5cba78", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "memberElementId": "6e96dce4-93f6-54b8-8b2e-77be485cf578", + "memberName": "earlierOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "ownedMemberElementId": "6e96dce4-93f6-54b8-8b2e-77be485cf578", + "ownedMemberFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "ownedMemberName": "earlierOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningRelationship": null, + "owningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + } + ], + "shortName": null, + "source": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "target": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "6e96dce4-93f6-54b8-8b2e-77be485cf578", + "endFeature": [], + "endOwningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "earlierOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "5fab2e3b-8e96-5f54-9432-0d218de28617" + } + ], + "ownedReferenceSubsetting": { + "@id": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df" + }, + "ownedRelationship": [ + { + "@id": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df" + }, + { + "@id": "5fab2e3b-8e96-5f54-9432-0d218de28617" + } + ], + "ownedSpecialization": [ + { + "@id": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df" + }, + { + "@id": "5fab2e3b-8e96-5f54-9432-0d218de28617" + } + ], + "ownedSubsetting": [ + { + "@id": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df" + }, + { + "@id": "5fab2e3b-8e96-5f54-9432-0d218de28617" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + "owningMembership": { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + "owningNamespace": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningRelationship": { + "@id": "d312acc6-fff4-59cc-9d02-8dca3d5cba78" + }, + "owningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningUsage": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "memberElementId": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b", + "memberName": "laterOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "ownedMemberElementId": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b", + "ownedMemberFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "ownedMemberName": "laterOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningRelationship": null, + "owningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "shortName": null, + "source": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "target": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b", + "endFeature": [], + "endOwningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "laterOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "7c2b623e-5884-5cfe-95fd-95d6d9865371" + } + ], + "ownedReferenceSubsetting": { + "@id": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6" + }, + "ownedRelationship": [ + { + "@id": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6" + }, + { + "@id": "7c2b623e-5884-5cfe-95fd-95d6d9865371" + } + ], + "ownedSpecialization": [ + { + "@id": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6" + }, + { + "@id": "7c2b623e-5884-5cfe-95fd-95d6d9865371" + } + ], + "ownedSubsetting": [ + { + "@id": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6" + }, + { + "@id": "7c2b623e-5884-5cfe-95fd-95d6d9865371" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + }, + "owningMembership": { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + }, + "owningNamespace": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningRelationship": { + "@id": "8c4ceb36-73a5-52f1-99a5-2ae07e97b127" + }, + "owningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningUsage": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1a2a774a-9b06-5bf3-a55f-2d77bb6360e6", + "general": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "owningRelationship": null, + "owningType": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "referencingFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "relatedElement": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "specific": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "subsettedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "subsettingFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "memberElementId": "02089055-4a65-5de8-bd2b-c66b0a627b0b", + "memberName": "effectful", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "ownedMemberElementId": "02089055-4a65-5de8-bd2b-c66b0a627b0b", + "ownedMemberFeature": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "ownedMemberName": "effectful", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "target": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b", + "@type": "TransitionUsage", + "actionDefinition": [], + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "effectful", + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "effectAction": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "elementId": "02089055-4a65-5de8-bd2b-c66b0a627b0b", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "featureMembership": [ + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + } + ], + "featureTarget": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "featuringType": [], + "guardExpression": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "membership": [ + { + "@id": "18967339-8d3a-58a9-b7c2-d4f3e5343e23" + }, + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929" + } + ], + "multiplicity": null, + "name": "effectful", + "nestedAction": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "ownedMembership": [ + { + "@id": "18967339-8d3a-58a9-b7c2-d4f3e5343e23" + }, + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "18967339-8d3a-58a9-b7c2-d4f3e5343e23" + }, + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929" + }, + { + "@id": "67919ffa-93ad-51c7-aca2-e19dc7566b71" + } + ], + "ownedSpecialization": [ + { + "@id": "67919ffa-93ad-51c7-aca2-e19dc7566b71" + } + ], + "ownedSubsetting": [ + { + "@id": "67919ffa-93ad-51c7-aca2-e19dc7566b71" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningDefinition": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningFeatureMembership": { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + }, + "owningMembership": { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + }, + "owningNamespace": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": { + "@id": "1abbc071-8fb4-53a0-a9ba-b46da1fb45d2" + }, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::effectful", + "shortName": null, + "source": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "succession": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "target": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "textualRepresentation": [], + "triggerAction": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "18967339-8d3a-58a9-b7c2-d4f3e5343e23", + "@type": "Membership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "18967339-8d3a-58a9-b7c2-d4f3e5343e23", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "memberElementId": "eb580a55-5649-5be2-9fe7-d7e6526f0c46", + "memberName": "x", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae", + "@type": "TransitionFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f748c477-974d-5d61-8411-c47cf6d54bae", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "kind": "effect", + "memberElement": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "memberElementId": "b9fa3146-fc73-528e-bcaa-1137d127278c", + "memberName": "reset", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "ownedMemberElementId": "b9fa3146-fc73-528e-bcaa-1137d127278c", + "ownedMemberFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "ownedMemberName": "reset", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelationship": null, + "owningType": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "shortName": null, + "source": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "target": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "textualRepresentation": [], + "transitionFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "visibility": "public" + }, + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c", + "@type": "PerformActionUsage", + "actionDefinition": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "aliasIds": [], + "behavior": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "reset", + "declaredShortName": null, + "definition": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "b9fa3146-fc73-528e-bcaa-1137d127278c", + "endFeature": [], + "endOwningType": null, + "eventOccurrence": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "reset", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "f9766571-41aa-5dd1-8764-26551e6a4d7c" + }, + { + "@id": "0a55051c-1d00-5da1-ae55-ae6f02c9f65a" + } + ], + "ownedSpecialization": [ + { + "@id": "f9766571-41aa-5dd1-8764-26551e6a4d7c" + }, + { + "@id": "0a55051c-1d00-5da1-ae55-ae6f02c9f65a" + } + ], + "ownedSubsetting": [ + { + "@id": "0a55051c-1d00-5da1-ae55-ae6f02c9f65a" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "f9766571-41aa-5dd1-8764-26551e6a4d7c" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + "owningMembership": { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + "owningNamespace": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelationship": { + "@id": "f748c477-974d-5d61-8411-c47cf6d54bae" + }, + "owningType": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningUsage": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "parameter": [], + "performedAction": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "portionKind": null, + "qualifiedName": "TransitionCases::Modes::effectful::reset", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "f9766571-41aa-5dd1-8764-26551e6a4d7c", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f9766571-41aa-5dd1-8764-26551e6a4d7c", + "general": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "owningRelationship": null, + "owningType": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "shortName": null, + "source": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "specific": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "target": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "textualRepresentation": [], + "type": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "typedFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + }, + { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5cf0f498-cc73-5d01-9558-6b3bb25a9929", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "memberElementId": "b73ea64c-b57c-564d-8cfa-b4d35d3547db", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "ownedMemberElementId": "b73ea64c-b57c-564d-8cfa-b4d35d3547db", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "shortName": null, + "source": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "target": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db", + "@type": "SuccessionAsUsage", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "b73ea64c-b57c-564d-8cfa-b4d35d3547db", + "endFeature": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "featureMembership": [ + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + } + ], + "featureTarget": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "membership": [ + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "ownedEndFeature": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "ownedFeature": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "ownedMembership": [ + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + }, + { + "@id": "0e2b1780-e9ba-5c31-a222-e524c49943a4" + } + ], + "ownedSpecialization": [ + { + "@id": "0e2b1780-e9ba-5c31-a222-e524c49943a4" + } + ], + "ownedSubsetting": [ + { + "@id": "0e2b1780-e9ba-5c31-a222-e524c49943a4" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929" + }, + "owningNamespace": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "5cf0f498-cc73-5d01-9558-6b3bb25a9929" + }, + "owningType": null, + "owningUsage": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "relatedFeature": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "sourceFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "targetFeature": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d8be9923-8572-51c4-b93c-936e88d93fe1", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "memberElementId": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737", + "memberName": "earlierOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "ownedMemberElementId": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737", + "ownedMemberFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "ownedMemberName": "earlierOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningRelationship": null, + "owningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + } + ], + "shortName": null, + "source": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "target": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737", + "endFeature": [], + "endOwningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "earlierOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "4210a887-80b2-5ea4-b852-156bd6b9e739" + } + ], + "ownedReferenceSubsetting": { + "@id": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef" + }, + "ownedRelationship": [ + { + "@id": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef" + }, + { + "@id": "4210a887-80b2-5ea4-b852-156bd6b9e739" + } + ], + "ownedSpecialization": [ + { + "@id": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef" + }, + { + "@id": "4210a887-80b2-5ea4-b852-156bd6b9e739" + } + ], + "ownedSubsetting": [ + { + "@id": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef" + }, + { + "@id": "4210a887-80b2-5ea4-b852-156bd6b9e739" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + "owningMembership": { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + "owningNamespace": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningRelationship": { + "@id": "d8be9923-8572-51c4-b93c-936e88d93fe1" + }, + "owningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningUsage": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "memberElementId": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded", + "memberName": "laterOccurrence", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "ownedMemberElementId": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded", + "ownedMemberFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "ownedMemberName": "laterOccurrence", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningRelationship": null, + "owningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "shortName": null, + "source": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "target": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded", + "endFeature": [], + "endOwningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": true, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": true, + "isVariation": false, + "mayTimeVary": true, + "member": [], + "membership": [], + "multiplicity": null, + "name": "laterOccurrence", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "5495ee57-6547-57ec-8fe5-929468a90ac4" + } + ], + "ownedReferenceSubsetting": { + "@id": "d4732792-1feb-5f6a-8d18-8826057bdc31" + }, + "ownedRelationship": [ + { + "@id": "d4732792-1feb-5f6a-8d18-8826057bdc31" + }, + { + "@id": "5495ee57-6547-57ec-8fe5-929468a90ac4" + } + ], + "ownedSpecialization": [ + { + "@id": "d4732792-1feb-5f6a-8d18-8826057bdc31" + }, + { + "@id": "5495ee57-6547-57ec-8fe5-929468a90ac4" + } + ], + "ownedSubsetting": [ + { + "@id": "d4732792-1feb-5f6a-8d18-8826057bdc31" + }, + { + "@id": "5495ee57-6547-57ec-8fe5-929468a90ac4" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + }, + "owningMembership": { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + }, + "owningNamespace": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningRelationship": { + "@id": "cda7b3ce-1abf-58da-9505-b4b06ce9c5cd" + }, + "owningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningUsage": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "d4732792-1feb-5f6a-8d18-8826057bdc31", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d4732792-1feb-5f6a-8d18-8826057bdc31", + "general": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "owningRelationship": null, + "owningType": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "referencingFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "relatedElement": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "specific": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "subsettedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "subsettingFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "29481ee0-157c-5855-b953-b9a6d7565474", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "29481ee0-157c-5855-b953-b9a6d7565474", + "general": { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "owningRelationship": null, + "owningType": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + } + ], + "shortName": null, + "source": [ + { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + } + ], + "specific": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "subclassifier": { + "@id": "93867435-c2c2-584f-9288-378804b1674c" + }, + "superclassifier": { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + }, + "target": [ + { + "@id": "8e9bd20f-ea8f-5a87-9759-f196d58bdd1a" + } + ], + "textualRepresentation": [] + }, + { + "@id": "a561334d-468f-5227-89f7-443784d7683d", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a561334d-468f-5227-89f7-443784d7683d", + "general": { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "owningRelationship": null, + "owningType": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + } + ], + "shortName": null, + "source": [ + { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + } + ], + "specific": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "subclassifier": { + "@id": "944239e2-da22-5343-b4d7-73d746f7ef1c" + }, + "superclassifier": { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + }, + "target": [ + { + "@id": "6e44fcc3-4ac4-5e93-a695-61791fa23309" + } + ], + "textualRepresentation": [] + }, + { + "@id": "4deaf063-0c81-50f1-8745-aa59e7a351da", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4deaf063-0c81-50f1-8745-aa59e7a351da", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "owningRelationship": null, + "owningType": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "specific": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "7db6375c-342d-53a4-b550-f257260ec578", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7db6375c-342d-53a4-b550-f257260ec578", + "general": { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "owningRelationship": null, + "owningType": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + } + ], + "shortName": null, + "source": [ + { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + } + ], + "specific": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "subclassifier": { + "@id": "81fda28a-0183-5937-9618-f3bb94591956" + }, + "superclassifier": { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + }, + "target": [ + { + "@id": "0f9954b1-8e58-5280-aa33-965dab2789b6" + } + ], + "textualRepresentation": [] + }, + { + "@id": "24dee6d6-1540-5fb0-955c-3f725233a22e", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "24dee6d6-1540-5fb0-955c-3f725233a22e", + "general": { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "owningRelationship": null, + "owningType": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + } + ], + "shortName": null, + "source": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "specific": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "subsettedFeature": { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + }, + "subsettingFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "target": [ + { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d54ee9d9-436d-5cf3-80ba-a438743d3523", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d54ee9d9-436d-5cf3-80ba-a438743d3523", + "general": { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "owningRelationship": null, + "owningType": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + } + ], + "shortName": null, + "source": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "specific": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "subsettedFeature": { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + }, + "subsettingFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "target": [ + { + "@id": "9e6571be-37ab-5c17-8af9-c3463c7e0d06" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1315343f-a477-5d77-a769-28f2c987ac02", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1315343f-a477-5d77-a769-28f2c987ac02", + "general": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "owningRelationship": null, + "owningType": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "shortName": null, + "source": [ + { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + } + ], + "specific": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "subsettedFeature": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "subsettingFeature": { + "@id": "52f41b33-b0dd-5c82-af0b-6c60345a9c6b" + }, + "target": [ + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "65c53ffd-9757-5d1c-ab82-ae033445a662", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "65c53ffd-9757-5d1c-ab82-ae033445a662", + "general": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "owningRelationship": null, + "owningType": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "redefiningFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "relatedElement": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "shortName": null, + "source": [ + { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + } + ], + "specific": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "subsettedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "subsettingFeature": { + "@id": "847c1458-09dd-569f-9f71-c5123904d723" + }, + "target": [ + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "textualRepresentation": [] + }, + { + "@id": "b18447d7-0dff-5bf2-b387-00cef2636883", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b18447d7-0dff-5bf2-b387-00cef2636883", + "general": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "owningRelationship": null, + "owningType": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "redefiningFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "relatedElement": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "shortName": null, + "source": [ + { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + } + ], + "specific": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "subsettedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "subsettingFeature": { + "@id": "7b9490e5-3eb5-5871-ab9c-1b535cccbdcf" + }, + "target": [ + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "textualRepresentation": [] + }, + { + "@id": "691fb9b1-3d99-53aa-b53a-b9cc1f3760a5", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "691fb9b1-3d99-53aa-b53a-b9cc1f3760a5", + "general": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "owningRelationship": null, + "owningType": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "shortName": null, + "source": [ + { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + } + ], + "specific": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "subsettedFeature": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "subsettingFeature": { + "@id": "f913e1e6-2fdf-57eb-b628-967530fecfb5" + }, + "target": [ + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "textualRepresentation": [] + }, + { + "@id": "eeda4c5c-673e-5581-af35-b2f8442a490f", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "eeda4c5c-673e-5581-af35-b2f8442a490f", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "owningRelationship": null, + "owningType": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "specific": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c01dc9ac-2caa-5b82-9dcf-74aa8d3cb2f5", + "general": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "owningRelationship": null, + "owningType": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "redefiningFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "relatedElement": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + } + ], + "shortName": null, + "source": [ + { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + } + ], + "specific": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "subsettedFeature": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "subsettingFeature": { + "@id": "c22bdd75-9c92-52d2-93b5-2c6cf2488a28" + }, + "target": [ + { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + } + ], + "textualRepresentation": [] + }, + { + "@id": "8ae173ab-9735-512f-9341-10bed354c9d6", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8ae173ab-9735-512f-9341-10bed354c9d6", + "general": { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "owningRelationship": null, + "owningType": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + } + ], + "shortName": null, + "source": [ + { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + } + ], + "specific": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "subsettedFeature": { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + }, + "subsettingFeature": { + "@id": "f6935a96-bd19-51cd-844b-2a22150106bc" + }, + "target": [ + { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + } + ], + "textualRepresentation": [] + }, + { + "@id": "7f30f3e7-5ea2-5518-9ad4-3cc03f55446d", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7f30f3e7-5ea2-5518-9ad4-3cc03f55446d", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningRelationship": null, + "owningType": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "specific": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "3548912e-7dd4-52f5-bfc9-acef23f01b9f", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3548912e-7dd4-52f5-bfc9-acef23f01b9f", + "general": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "owningRelationship": null, + "owningType": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "redefiningFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "relatedElement": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + } + ], + "shortName": null, + "source": [ + { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + } + ], + "specific": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "subsettedFeature": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "subsettingFeature": { + "@id": "14a059af-4d3b-5a44-8cb9-f48028c36af9" + }, + "target": [ + { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + } + ], + "textualRepresentation": [] + }, + { + "@id": "324ee4f2-385a-5d20-8fbe-a2b3594ae77b", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "324ee4f2-385a-5d20-8fbe-a2b3594ae77b", + "general": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "owningRelationship": null, + "owningType": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "shortName": null, + "source": [ + { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + } + ], + "specific": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "subsettedFeature": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "subsettingFeature": { + "@id": "84b85b32-2e9a-5718-bb6a-428ab490d1de" + }, + "target": [ + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "bc019a85-a7bf-5648-8587-a6a06cb56812", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "bc019a85-a7bf-5648-8587-a6a06cb56812", + "general": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "owningRelationship": null, + "owningType": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "referencingFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "relatedElement": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + } + ], + "specific": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "subsettedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "subsettingFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d627471b-a3f9-5d6b-bb0b-d458e748936c", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d627471b-a3f9-5d6b-bb0b-d458e748936c", + "general": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "owningRelationship": null, + "owningType": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "redefiningFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "relatedElement": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "shortName": null, + "source": [ + { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + } + ], + "specific": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "subsettedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "subsettingFeature": { + "@id": "99957371-03b3-5a8c-892c-a3bef51b298c" + }, + "target": [ + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1eae1db4-3568-5414-8023-f35ab74d5c1e", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1eae1db4-3568-5414-8023-f35ab74d5c1e", + "general": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "owningRelationship": null, + "owningType": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "redefiningFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "relatedElement": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "shortName": null, + "source": [ + { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + } + ], + "specific": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "subsettedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "subsettingFeature": { + "@id": "f3300e66-e9a6-5ccc-b327-4a61dcd3227f" + }, + "target": [ + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "textualRepresentation": [] + }, + { + "@id": "957cb8ea-92cc-5244-a909-fafdccd08c8c", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "957cb8ea-92cc-5244-a909-fafdccd08c8c", + "general": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "owningRelationship": null, + "owningType": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "shortName": null, + "source": [ + { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + } + ], + "specific": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "subsettedFeature": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "subsettingFeature": { + "@id": "18b3eefc-5ef5-5abe-84a3-fb44836d20ee" + }, + "target": [ + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "textualRepresentation": [] + }, + { + "@id": "8cc6b285-b341-5e87-b1de-dc954e0f18c4", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8cc6b285-b341-5e87-b1de-dc954e0f18c4", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "owningRelationship": null, + "owningType": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "specific": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "20539639-4f71-5bee-81d5-ccc04b72bb08", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "20539639-4f71-5bee-81d5-ccc04b72bb08", + "general": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "owningRelationship": null, + "owningType": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "redefiningFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "relatedElement": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + } + ], + "shortName": null, + "source": [ + { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + } + ], + "specific": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "subsettedFeature": { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + }, + "subsettingFeature": { + "@id": "85a278ad-aed1-54ec-be04-11e9f72daa5a" + }, + "target": [ + { + "@id": "79252dcf-845e-5151-a0e9-28ee09987171" + } + ], + "textualRepresentation": [] + }, + { + "@id": "cd462f79-ba27-5a3a-9c17-5ce1566a11a1", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "cd462f79-ba27-5a3a-9c17-5ce1566a11a1", + "general": { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "owningRelationship": null, + "owningType": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + } + ], + "shortName": null, + "source": [ + { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + } + ], + "specific": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "subsettedFeature": { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + }, + "subsettingFeature": { + "@id": "89b1754b-de6e-5320-af5c-ec8eecfcf0ac" + }, + "target": [ + { + "@id": "7a441137-6036-55c3-8112-b1404ad90a5f" + } + ], + "textualRepresentation": [] + }, + { + "@id": "232484ae-2333-5e06-a1ff-0d64215a4466", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "232484ae-2333-5e06-a1ff-0d64215a4466", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningRelationship": null, + "owningType": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "specific": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "24bec017-4527-55fd-85b1-d9e6e5072f81", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "24bec017-4527-55fd-85b1-d9e6e5072f81", + "general": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "owningRelationship": null, + "owningType": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "redefiningFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "relatedElement": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + } + ], + "shortName": null, + "source": [ + { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + } + ], + "specific": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "subsettedFeature": { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + }, + "subsettingFeature": { + "@id": "20de5d5b-15d3-54ce-bb2a-9f2bbc6a534a" + }, + "target": [ + { + "@id": "780fbe59-dd70-56b5-bbd2-3d2f904daff3" + } + ], + "textualRepresentation": [] + }, + { + "@id": "876777a1-4824-58f7-867b-09c917a39882", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "876777a1-4824-58f7-867b-09c917a39882", + "general": { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelationship": null, + "owningType": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + } + ], + "shortName": null, + "source": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "specific": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "subsettedFeature": { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + }, + "subsettingFeature": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "target": [ + { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + } + ], + "textualRepresentation": [] + }, + { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a", + "@type": "ReturnParameterMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "memberElementId": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d", + "memberName": "result", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "ownedMemberElementId": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d", + "ownedMemberFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "ownedMemberName": "result", + "ownedMemberParameter": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelationship": null, + "owningType": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "shortName": null, + "source": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "target": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": "out", + "documentation": [], + "elementId": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "result", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [ + { + "@id": "00f94f53-abe5-5602-bc1c-0585bec29dcd" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "609cd6d7-c3b5-5d68-ae62-1980dffda019" + }, + { + "@id": "e38fa9a0-a287-5e0d-9999-e07577cf0e65" + }, + { + "@id": "00f94f53-abe5-5602-bc1c-0585bec29dcd" + } + ], + "ownedSpecialization": [ + { + "@id": "609cd6d7-c3b5-5d68-ae62-1980dffda019" + }, + { + "@id": "00f94f53-abe5-5602-bc1c-0585bec29dcd" + } + ], + "ownedSubsetting": [ + { + "@id": "609cd6d7-c3b5-5d68-ae62-1980dffda019" + }, + { + "@id": "00f94f53-abe5-5602-bc1c-0585bec29dcd" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "e38fa9a0-a287-5e0d-9999-e07577cf0e65" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningFeatureMembership": { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + "owningMembership": { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + "owningNamespace": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelationship": { + "@id": "f01798f0-4af1-5e9c-9ffb-8e5ca152800a" + }, + "owningType": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "d5b4e7df-e644-5f2f-b95e-cf6f1f6c076d" + }, + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "unioningType": [] + }, + { + "@id": "609cd6d7-c3b5-5d68-ae62-1980dffda019", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "609cd6d7-c3b5-5d68-ae62-1980dffda019", + "general": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningRelationship": null, + "owningType": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "shortName": null, + "source": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "specific": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "subsettedFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "subsettingFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "target": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "e38fa9a0-a287-5e0d-9999-e07577cf0e65", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e38fa9a0-a287-5e0d-9999-e07577cf0e65", + "featureOfType": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "featuringType": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "shortName": null, + "source": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "target": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "textualRepresentation": [] + }, + { + "@id": "00f94f53-abe5-5602-bc1c-0585bec29dcd", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "00f94f53-abe5-5602-bc1c-0585bec29dcd", + "general": { + "@id": "d4c65e7a-f5cd-5e32-bb56-93a0cfa01d23" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "owningRelationship": null, + "owningType": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "d4c65e7a-f5cd-5e32-bb56-93a0cfa01d23" + }, + "redefiningFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "relatedElement": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + { + "@id": "d4c65e7a-f5cd-5e32-bb56-93a0cfa01d23" + } + ], + "shortName": null, + "source": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "specific": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "subsettedFeature": { + "@id": "d4c65e7a-f5cd-5e32-bb56-93a0cfa01d23" + }, + "subsettingFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "target": [ + { + "@id": "d4c65e7a-f5cd-5e32-bb56-93a0cfa01d23" + } + ], + "textualRepresentation": [] + }, + { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "1ee5bd99-a694-5061-8d5d-fe13517abff8", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "memberElementId": "39d52089-5ce9-5a43-ba79-e0c91b78139d", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "ownedMemberElementId": "39d52089-5ce9-5a43-ba79-e0c91b78139d", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "shortName": null, + "source": [ + { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + } + ], + "target": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d", + "@type": "BindingConnector", + "aliasIds": [], + "association": [], + "chainingFeature": [], + "connectorEnd": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "defaultFeaturingType": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "39d52089-5ce9-5a43-ba79-e0c91b78139d", + "endFeature": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "endOwningType": null, + "feature": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "featureMembership": [ + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + } + ], + "featureTarget": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "membership": [ + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "ownedEndFeature": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "ownedFeature": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "ownedMembership": [ + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelatedElement": [], + "ownedRelationship": [ + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8" + }, + "owningNamespace": { + "@id": "f8b32c4a-91e0-58f1-a602-e8b5a02af4ac" + }, + "owningRelatedElement": null, + "owningRelationship": { + "@id": "1ee5bd99-a694-5061-8d5d-fe13517abff8" + }, + "owningType": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "relatedFeature": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "shortName": null, + "source": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "sourceFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "target": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "targetFeature": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "c229ffed-c89e-5ab8-972b-19f087c68b53", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "memberElementId": "0c39244b-b4df-5128-88ad-efd31c9873a6", + "memberName": "thisThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "ownedMemberElementId": "0c39244b-b4df-5128-88ad-efd31c9873a6", + "ownedMemberFeature": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "ownedMemberName": "thisThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningRelationship": null, + "owningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + } + ], + "shortName": null, + "source": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "target": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "0c39244b-b4df-5128-88ad-efd31c9873a6", + "endFeature": [], + "endOwningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "thisThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "d79c4426-9cee-5059-9f0f-fda9d98346a7" + }, + "ownedRelationship": [ + { + "@id": "d79c4426-9cee-5059-9f0f-fda9d98346a7" + }, + { + "@id": "993feabc-0a0e-5253-8066-74415eea3c8c" + } + ], + "ownedSpecialization": [ + { + "@id": "d79c4426-9cee-5059-9f0f-fda9d98346a7" + } + ], + "ownedSubsetting": [ + { + "@id": "d79c4426-9cee-5059-9f0f-fda9d98346a7" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "993feabc-0a0e-5253-8066-74415eea3c8c" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningFeatureMembership": { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + "owningMembership": { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + "owningNamespace": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningRelationship": { + "@id": "c229ffed-c89e-5ab8-972b-19f087c68b53" + }, + "owningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "unioningType": [] + }, + { + "@id": "d79c4426-9cee-5059-9f0f-fda9d98346a7", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d79c4426-9cee-5059-9f0f-fda9d98346a7", + "general": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "owningRelationship": null, + "owningType": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "referencingFeature": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "relatedElement": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "shortName": null, + "source": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + } + ], + "specific": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "subsettedFeature": { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + }, + "subsettingFeature": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "target": [ + { + "@id": "2f8cf3a6-adcf-5f8d-a34a-24a38eb7dd5d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "993feabc-0a0e-5253-8066-74415eea3c8c", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "993feabc-0a0e-5253-8066-74415eea3c8c", + "featureOfType": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "featuringType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "shortName": null, + "source": [ + { + "@id": "0c39244b-b4df-5128-88ad-efd31c9873a6" + } + ], + "target": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "06afb105-f542-5443-94ca-b044b0711b39", + "@type": "EndFeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "06afb105-f542-5443-94ca-b044b0711b39", + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "memberElementId": "5712c2ba-0774-5bd7-b49d-834f2e724450", + "memberName": "sameThing", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "ownedMemberElementId": "5712c2ba-0774-5bd7-b49d-834f2e724450", + "ownedMemberFeature": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "ownedMemberName": "sameThing", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningRelationship": null, + "owningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "shortName": null, + "source": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "target": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "5712c2ba-0774-5bd7-b49d-834f2e724450", + "endFeature": [], + "endOwningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "sameThing", + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "70adb5d0-1a0b-502f-98d0-aaf39272a696" + }, + "ownedRelationship": [ + { + "@id": "70adb5d0-1a0b-502f-98d0-aaf39272a696" + }, + { + "@id": "d14c7479-75f2-5ce4-955b-623d0fc601bf" + } + ], + "ownedSpecialization": [ + { + "@id": "70adb5d0-1a0b-502f-98d0-aaf39272a696" + } + ], + "ownedSubsetting": [ + { + "@id": "70adb5d0-1a0b-502f-98d0-aaf39272a696" + } + ], + "ownedTypeFeaturing": [ + { + "@id": "d14c7479-75f2-5ce4-955b-623d0fc601bf" + } + ], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningFeatureMembership": { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + }, + "owningMembership": { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + }, + "owningNamespace": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "owningRelationship": { + "@id": "06afb105-f542-5443-94ca-b044b0711b39" + }, + "owningType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "d5b4e7df-e644-5f2f-b95e-cf6f1f6c076d" + }, + { + "@id": "d1e9242d-b2e3-5270-bf69-4f4fb0447193" + } + ], + "unioningType": [] + }, + { + "@id": "70adb5d0-1a0b-502f-98d0-aaf39272a696", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "70adb5d0-1a0b-502f-98d0-aaf39272a696", + "general": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "owningRelationship": null, + "owningType": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "referencingFeature": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "relatedElement": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "shortName": null, + "source": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "specific": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "subsettedFeature": { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + }, + "subsettingFeature": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "target": [ + { + "@id": "7d9a7dbf-840e-5d56-80cf-4f84c26a659d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "d14c7479-75f2-5ce4-955b-623d0fc601bf", + "@type": "TypeFeaturing", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "d14c7479-75f2-5ce4-955b-623d0fc601bf", + "featureOfType": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "featuringType": { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeatureOfType": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + }, + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "shortName": null, + "source": [ + { + "@id": "5712c2ba-0774-5bd7-b49d-834f2e724450" + } + ], + "target": [ + { + "@id": "39d52089-5ce9-5a43-ba79-e0c91b78139d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "8c125c6f-8f73-5a01-8125-fcf3aa26c89a", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8c125c6f-8f73-5a01-8125-fcf3aa26c89a", + "general": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "owningRelationship": null, + "owningType": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "shortName": null, + "source": [ + { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + } + ], + "specific": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "subsettedFeature": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "subsettingFeature": { + "@id": "a5bbd945-f7d2-52da-89e1-87636e299f51" + }, + "target": [ + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "27abbd5b-fe9e-5d42-bb3c-cd6ab40205df", + "general": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "owningRelationship": null, + "owningType": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "referencingFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "relatedElement": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "shortName": null, + "source": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + } + ], + "specific": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "subsettedFeature": { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + }, + "subsettingFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "target": [ + { + "@id": "cca4f9b5-be00-50ed-86ee-8b17efab256d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "5fab2e3b-8e96-5f54-9432-0d218de28617", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5fab2e3b-8e96-5f54-9432-0d218de28617", + "general": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "owningRelationship": null, + "owningType": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "redefiningFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "relatedElement": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "shortName": null, + "source": [ + { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + } + ], + "specific": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "subsettedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "subsettingFeature": { + "@id": "6e96dce4-93f6-54b8-8b2e-77be485cf578" + }, + "target": [ + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "textualRepresentation": [] + }, + { + "@id": "7c2b623e-5884-5cfe-95fd-95d6d9865371", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7c2b623e-5884-5cfe-95fd-95d6d9865371", + "general": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "owningRelationship": null, + "owningType": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "redefiningFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "relatedElement": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "shortName": null, + "source": [ + { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + } + ], + "specific": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "subsettedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "subsettingFeature": { + "@id": "9b43ac9e-2ad8-5aff-968c-b2bce4ad476b" + }, + "target": [ + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "textualRepresentation": [] + }, + { + "@id": "67919ffa-93ad-51c7-aca2-e19dc7566b71", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "67919ffa-93ad-51c7-aca2-e19dc7566b71", + "general": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "owningRelationship": null, + "owningType": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "shortName": null, + "source": [ + { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + } + ], + "specific": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "subsettedFeature": { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + }, + "subsettingFeature": { + "@id": "02089055-4a65-5de8-bd2b-c66b0a627b0b" + }, + "target": [ + { + "@id": "59665626-a20d-5308-aafb-d676b210142f" + } + ], + "textualRepresentation": [] + }, + { + "@id": "0a55051c-1d00-5da1-ae55-ae6f02c9f65a", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0a55051c-1d00-5da1-ae55-ae6f02c9f65a", + "general": { + "@id": "0cc065ef-4e93-5aed-a3f3-5e8cbb417021" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "owningRelationship": null, + "owningType": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + { + "@id": "0cc065ef-4e93-5aed-a3f3-5e8cbb417021" + } + ], + "shortName": null, + "source": [ + { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + } + ], + "specific": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "subsettedFeature": { + "@id": "0cc065ef-4e93-5aed-a3f3-5e8cbb417021" + }, + "subsettingFeature": { + "@id": "b9fa3146-fc73-528e-bcaa-1137d127278c" + }, + "target": [ + { + "@id": "0cc065ef-4e93-5aed-a3f3-5e8cbb417021" + } + ], + "textualRepresentation": [] + }, + { + "@id": "0e2b1780-e9ba-5c31-a222-e524c49943a4", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0e2b1780-e9ba-5c31-a222-e524c49943a4", + "general": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "owningRelationship": null, + "owningType": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "shortName": null, + "source": [ + { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + } + ], + "specific": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "subsettedFeature": { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + }, + "subsettingFeature": { + "@id": "b73ea64c-b57c-564d-8cfa-b4d35d3547db" + }, + "target": [ + { + "@id": "0e1bba0a-81f0-518c-8415-d1976bd38f8d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "7218a1db-a85d-5c02-b8ad-1ad5d26eaeef", + "general": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "owningRelationship": null, + "owningType": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "referencingFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "relatedElement": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "shortName": null, + "source": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + } + ], + "specific": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "subsettedFeature": { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + }, + "subsettingFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "target": [ + { + "@id": "eb580a55-5649-5be2-9fe7-d7e6526f0c46" + } + ], + "textualRepresentation": [] + }, + { + "@id": "4210a887-80b2-5ea4-b852-156bd6b9e739", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4210a887-80b2-5ea4-b852-156bd6b9e739", + "general": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "owningRelationship": null, + "owningType": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "redefiningFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "relatedElement": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "shortName": null, + "source": [ + { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + } + ], + "specific": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "subsettedFeature": { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + }, + "subsettingFeature": { + "@id": "c1d230fb-17eb-5ac1-b3d3-b768eb68b737" + }, + "target": [ + { + "@id": "7d7065b6-1bb8-5bb5-b421-cc92f2e84584" + } + ], + "textualRepresentation": [] + }, + { + "@id": "5495ee57-6547-57ec-8fe5-929468a90ac4", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "5495ee57-6547-57ec-8fe5-929468a90ac4", + "general": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "owningRelationship": null, + "owningType": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "redefiningFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "relatedElement": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "shortName": null, + "source": [ + { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + } + ], + "specific": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "subsettedFeature": { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + }, + "subsettingFeature": { + "@id": "c1373d24-0ddb-5026-b8ce-1e7ef44d0ded" + }, + "target": [ + { + "@id": "99bd4b60-e5a9-55fb-8cea-1dcf517e50ec" + } + ], + "textualRepresentation": [] + } +] diff --git a/tests/export/toolkit_json_import_test.go b/tests/export/toolkit_json_import_test.go new file mode 100644 index 0000000000..cedf9ab290 --- /dev/null +++ b/tests/export/toolkit_json_import_test.go @@ -0,0 +1,223 @@ +package export_test + +import ( + "bytes" + "encoding/json" + "os" + "path/filepath" + "strings" + "testing" + + "github.com/Open-MBEE/OpenSysML/internal/syntax/diag" + "github.com/Open-MBEE/OpenSysML/internal/syntax/parser" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" + "github.com/Open-MBEE/OpenSysML/internal/translate/export" + "github.com/Open-MBEE/OpenSysML/internal/workspace/model" +) + +func toolkitFixture(t *testing.T, name string) []byte { + t.Helper() + data, err := os.ReadFile(filepath.Join("testdata", "interchange", name)) + if err != nil { + t.Fatal(err) + } + return data +} + +func decodeToolkitFixture(t *testing.T, name string, warn func(string)) []byte { + t.Helper() + graph, err := export.ReadAPIJSON(toolkitFixture(t, name)) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + out, err := export.ToSysMLWarn(graph, warn) + if err != nil { + t.Fatalf("ToSysMLWarn: %v", err) + } + file := source.New(name+".sysml", out) + p := parser.New(file) + p.ParseFile() + if len(p.Diagnostics) > 0 { + t.Fatalf("the decoded notation does not parse: %v\n%s", p.Diagnostics, out) + } + ws := model.NewWorkspace() + ws.Open(name+".sysml", out, 1) + for _, diagnostic := range ws.Diagnostics(name + ".sysml") { + if diagnostic.Severity == diag.SeverityError { + t.Errorf("the decoded notation does not validate: %s\n%s", diagnostic.Message, out) + } + } + return out +} + +func TestToolkitFlowEndAndPayload(t *testing.T) { + out := decodeToolkitFixture(t, "flow_ends.toolkit.full.json", nil) + want := toolkitFixture(t, "flow_ends.golden.sysml") + if !bytes.Equal(out, want) { + t.Fatalf("the decoded flow notation changed:\n--- want ---\n%s\n--- got ---\n%s", want, out) + } + if !strings.Contains(string(out), "flow of Payload from source.holder.payload to target.holder.payload;") { + t.Fatalf("the flow ends or payload were not written in the flow head:\n%s", out) + } + if strings.Contains(string(out), "composite flow") { + t.Fatalf("the flow has a composite modifier the toolkit parser does not accept:\n%s", out) + } +} + +func TestToolkitFlowEndRefusesUnrepresentableDetails(t *testing.T) { + for _, tc := range []struct { + name string + edit func([]map[string]any) + want string + }{ + { + name: "declared name", + edit: func(objects []map[string]any) { + for _, object := range objects { + if object["@type"] == "FlowEnd" { + object["declaredName"] = "explicit" + return + } + } + }, + want: "declares a name", + }, + { + name: "mismatched derived name", + edit: func(objects []map[string]any) { + for _, object := range objects { + if object["@type"] == "ReferenceUsage" && object["name"] == "payload" { + object["name"] = "wrong" + } + } + }, + want: "derived name does not match", + }, + } { + t.Run(tc.name, func(t *testing.T) { + var objects []map[string]any + if err := json.Unmarshal(toolkitFixture(t, "flow_ends.toolkit.full.json"), &objects); err != nil { + t.Fatal(err) + } + tc.edit(objects) + data, err := json.Marshal(objects) + if err != nil { + t.Fatal(err) + } + graph, err := export.ReadAPIJSON(data) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + _, err = export.ToSysML(graph) + if err == nil || !strings.Contains(err.Error(), tc.want) { + t.Fatalf("ToSysML error = %v, want %q", err, tc.want) + } + }) + } +} + +func TestToolkitTransitionClauses(t *testing.T) { + out := decodeToolkitFixture(t, "transitions.toolkit.full.json", nil) + want := toolkitFixture(t, "transitions.golden.sysml") + if !bytes.Equal(out, want) { + t.Fatalf("the decoded transition notation changed:\n--- want ---\n%s\n--- got ---\n%s", want, out) + } + text := string(out) + for _, clause := range []string{ + "transition triggered first x accept Go then y;", + "transition guarded first y accept Go if ready then x;", + "transition effectful first x do action reset : Reset then y;", + } { + if !strings.Contains(text, clause) { + t.Errorf("the decoded transition notation lacks %q:\n%s", clause, text) + } + } + for _, line := range strings.Split(text, "\n") { + if strings.TrimSpace(line) == "first start then x;" { + return + } + } + t.Fatalf("the entry was not kept as the positional `first start then x;` form:\n%s", text) +} + +func TestToolkitInferredSuccessionClause(t *testing.T) { + out := decodeToolkitFixture(t, "successions.toolkit.full.json", nil) + want := toolkitFixture(t, "successions.golden.sysml") + if !bytes.Equal(out, want) { + t.Fatalf("the decoded succession notation changed:\n--- want ---\n%s\n--- got ---\n%s", want, out) + } + if !strings.Contains(string(out), "succession first firstEvent then secondEvent;") { + t.Fatalf("the inferred succession lacks its required `first` clause:\n%s", out) + } +} + +func TestToolkitLibraryFallbackWarns(t *testing.T) { + const oldID = "11111111-2222-4333-8444-555555555555" + var warnings []string + // The toolkit fixture's ScalarValues::Real stub has a hand-edited element ID. + out := decodeToolkitFixture(t, "library_identity.toolkit.full.json", func(message string) { + warnings = append(warnings, message) + }) + want := toolkitFixture(t, "library_identity.golden.sysml") + if !bytes.Equal(out, want) { + t.Fatalf("the decoded library notation changed:\n--- want ---\n%s\n--- got ---\n%s", want, out) + } + if !strings.Contains(string(out), "library package DocumentLibrary") { + t.Fatalf("the document-defined library package was not written as notation:\n%s", out) + } + if len(warnings) != 1 { + t.Fatalf("warnings = %v, want one library identity warning", warnings) + } + for _, part := range []string{oldID, "resolved by its qualified name ScalarValues::Real", "14c0aa22-5489-59b5-b438-ded26e83ba31"} { + if !strings.Contains(warnings[0], part) { + t.Errorf("warning %q does not identify %q", warnings[0], part) + } + } +} + +func TestToolkitUnmatchedLibraryStubRefuses(t *testing.T) { + graph, err := export.ReadAPIJSON(toolkitFixture(t, "library_unmatched.toolkit.full.json")) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + _, err = export.ToSysMLWarn(graph, nil) + if err == nil { + t.Fatal("an unmatched library stub decoded") + } + for _, part := range []string{"11111111-2222-4333-8444-555555555555", "Missing::MissingType"} { + if !strings.Contains(err.Error(), part) { + t.Errorf("error %q does not identify %q", err, part) + } + } +} + +func TestToolkitLibraryFallbackRequiresCompatibleMetaclass(t *testing.T) { + const oldID = "11111111-2222-4333-8444-555555555555" + var objects []map[string]any + if err := json.Unmarshal(toolkitFixture(t, "library_identity.toolkit.full.json"), &objects); err != nil { + t.Fatal(err) + } + for _, object := range objects { + if object["@id"] == oldID { + object["@type"] = "PartDefinition" + } + } + data, err := json.Marshal(objects) + if err != nil { + t.Fatal(err) + } + graph, err := export.ReadAPIJSON(data) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + var warnings []string + _, err = export.ToSysMLWarn(graph, func(message string) { + warnings = append(warnings, message) + }) + if err == nil || !strings.Contains(err.Error(), oldID) || !strings.Contains(err.Error(), "ScalarValues::Real") { + t.Fatalf("ToSysMLWarn error = %v, want the incompatible library identity and stated name", err) + } + if len(warnings) != 0 { + t.Errorf("warnings = %v, want no fallback warning for an incompatible metaclass", warnings) + } +} diff --git a/tests/export/variation_rdf_test.go b/tests/export/variation_rdf_test.go index fd6131a9bf..37438e24ca 100644 --- a/tests/export/variation_rdf_test.go +++ b/tests/export/variation_rdf_test.go @@ -109,6 +109,30 @@ func TestEnumerationVariationComesBackFromTheGraphAlone(t *testing.T) { } } +func TestForeignEnumerationAbstractFlagWritesNoKeyword(t *testing.T) { + turtle, err := convert.Convert("enum.sysml", []byte(enumVariationModel), convert.FormatSysML, convert.FormatTurtle) + if err != nil { + t.Fatalf("to turtle: %v", err) + } + turtle = withoutTriples(t, withoutSourceText(t, turtle), "sysml:isAbstract") + graph, err := rdf.ParseTurtle(turtle) + if err != nil { + t.Fatalf("parse turtle: %v", err) + } + graph.Add(rdf.ElementIRI("V::Level"), rdf.IRI(rdf.SysML+"isAbstract"), rdf.Bool(true)) + + text, err := export.ToSysML(graph) + if err != nil { + t.Fatalf("back to notation: %v", err) + } + if strings.Contains(string(text), "abstract enum def") { + t.Fatalf("enumeration abstractness has no grammar prefix:\n%s", text) + } + if _, err := convert.Convert("enum.sysml", text, convert.FormatSysML, convert.FormatTurtle); err != nil { + t.Fatalf("parse notation: %v\n%s", err, text) + } +} + // A graph from another tool may flag an enumerated value sysml:isVariant under // a plain OwningMembership; the flag is still not written back as `variant`. func TestForeignEnumeratedValueFlagWritesNoKeyword(t *testing.T) { From 5e46a828186ed0a7e85f74022c292f7ce6b3efbe Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sat, 3 Oct 2026 20:53:57 +0000 Subject: [PATCH 02/10] feat: accept api-json model files wherever a model loads Co-Authored-By: jason.han --- .../api-json-model-loading.added.md | 1 + client/python/opensysml/__init__.py | 2 +- cmd/sysml/api_json_load_test.go | 61 ++++++++++++++++ docs/guide/03-command-line.md | 3 + docs/guide/04-repl.md | 6 ++ docs/reference/rdf-mapping.md | 4 ++ internal/frontend/grpc/cache.go | 1 + internal/frontend/grpc/service.go | 29 +++++++- internal/frontend/grpc/service_test.go | 72 +++++++++++++++++++ internal/frontend/repl/load.go | 24 ++++++- internal/frontend/repl/load_test.go | 35 +++++++++ internal/frontend/repl/run.go | 4 +- internal/frontend/repl/session.go | 5 +- internal/syntax/source/kind.go | 16 +++-- internal/syntax/source/source_test.go | 8 +++ internal/translate/convert/convert.go | 14 ++++ .../translate/convert/model_source_test.go | 44 ++++++++++++ 17 files changed, 317 insertions(+), 12 deletions(-) create mode 100644 changes/unreleased/api-json-model-loading.added.md create mode 100644 cmd/sysml/api_json_load_test.go create mode 100644 internal/translate/convert/model_source_test.go diff --git a/changes/unreleased/api-json-model-loading.added.md b/changes/unreleased/api-json-model-loading.added.md new file mode 100644 index 0000000000..e2362c2254 --- /dev/null +++ b/changes/unreleased/api-json-model-loading.added.md @@ -0,0 +1 @@ +- **Load API element-form JSON files directly.** Explicitly named `.json` model files are converted to SysML notation before parsing; diagnostics refer to that notation. diff --git a/client/python/opensysml/__init__.py b/client/python/opensysml/__init__.py index 39fe2fe17f..d5fd379df3 100644 --- a/client/python/opensysml/__init__.py +++ b/client/python/opensysml/__init__.py @@ -213,7 +213,7 @@ def parse_sources(documents, host='localhost', port=None, strict=False, def load(file_path, host='localhost', port=None, strict=False, strict_conformance=False): - """Load a SysML model from file using the default connection. + """Load a SysML model from a .sysml, .kerml, or API element-form .json file. Convenience function that uses a module-level singleton connection. diff --git a/cmd/sysml/api_json_load_test.go b/cmd/sysml/api_json_load_test.go new file mode 100644 index 0000000000..1288a4740d --- /dev/null +++ b/cmd/sysml/api_json_load_test.go @@ -0,0 +1,61 @@ +package main + +import ( + "bytes" + "errors" + "os/exec" + "path/filepath" + "strings" + "testing" +) + +func runValidatePath(t *testing.T, binary, path string) runOutcome { + t.Helper() + cmd := exec.Command(binary, "-validate", path) + var stdout, stderr bytes.Buffer + cmd.Stdout, cmd.Stderr = &stdout, &stderr + err := cmd.Run() + result := runOutcome{stdout: stdout.String(), stderr: stderr.String()} + var exit *exec.ExitError + switch { + case err == nil: + case errors.As(err, &exit): + result.status = exit.ExitCode() + default: + t.Fatalf("running -validate %s: %v\n%s", path, err, result.output()) + } + return result +} + +func apiJSONFixture(t *testing.T, name string) string { + t.Helper() + path, err := filepath.Abs(filepath.Join("..", "..", "tests", "export", "testdata", "interchange", name)) + if err != nil { + t.Fatal(err) + } + return path +} + +func TestValidateAPIJSONFiles(t *testing.T) { + binary := buildCLI(t) + + flowEnds := runValidatePath(t, binary, apiJSONFixture(t, "flow_ends.toolkit.full.json")) + if flowEnds.status != 0 || !strings.Contains(flowEnds.output(), "no errors") { + t.Errorf("validating toolkit flow ends exited %d:\n%s", flowEnds.status, flowEnds.output()) + } + + library := runValidatePath(t, binary, apiJSONFixture(t, "library_identity.toolkit.full.json")) + if library.status != 0 || !strings.Contains(library.output(), "warning: the library element") { + t.Errorf("validating toolkit library identities exited %d:\n%s", library.status, library.output()) + } +} + +func TestValidateUnconvertibleAPIJSONNamesFile(t *testing.T) { + binary := buildCLI(t) + path := apiJSONFixture(t, "library_unmatched.toolkit.full.json") + + result := runValidatePath(t, binary, path) + if result.status == 0 || !strings.Contains(result.output(), path) { + t.Fatalf("failed conversion did not name %s (exit %d):\n%s", path, result.status, result.output()) + } +} diff --git a/docs/guide/03-command-line.md b/docs/guide/03-command-line.md index 4012057659..aa32979828 100644 --- a/docs/guide/03-command-line.md +++ b/docs/guide/03-command-line.md @@ -182,6 +182,9 @@ sysml: bad.sysml did not analyse cleanly; no check was made exit=2 ``` +An explicitly named API element-form `.json` file is converted before validation. Diagnostic +positions refer to the converted SysML notation, not to positions in the JSON document. + A single `-` stands for standard input wherever a file name is accepted, so you can pipe a model in; its diagnostics are reported against ``. To read a file that is actually named `-`, write `./-`. `-convert` needs `-from` for piped input, because a stream has no file diff --git a/docs/guide/04-repl.md b/docs/guide/04-repl.md index 22f15972f7..b724e2a628 100644 --- a/docs/guide/04-repl.md +++ b/docs/guide/04-repl.md @@ -117,6 +117,9 @@ it again at the prompt *replaces* it (`note: replaced package …`) rather than loaded file, edit it and load it again. Tab completion completes paths after `%load` and `%save`, and meta-commands and symbol names everywhere else. +A specifically named API element-form `.json` file is converted and loaded; directory and glob +expansion still collects only `.sysml` and `.kerml` files. + A loaded file's imports are followed to its neighbors: when a file imports a root namespace that neither the loaded files nor the standard library declare, the `.sysml` and `.kerml` files beside and below it are searched for one declaring that name, and each is loaded too, its own imports @@ -130,6 +133,9 @@ session, so the next submission is parsed against the model as it stood before t non-interactive use, a load's diagnostics are errors, so a script that loads a malformed file fails rather than continuing against an empty session. +An explicitly named API element-form `.json` file is converted to SysML notation before loading; +diagnostic positions refer to the converted notation, not to positions in the JSON document. + Each loaded file is a document of its own, analysed as the editor and the checker analyse it, while everything typed at the prompt forms one transcript document. The transcript is kept under the name ``, which is therefore reserved: a file whose path is literally `` diff --git a/docs/reference/rdf-mapping.md b/docs/reference/rdf-mapping.md index 9d12566bac..0891707c39 100644 --- a/docs/reference/rdf-mapping.md +++ b/docs/reference/rdf-mapping.md @@ -1967,6 +1967,10 @@ element it cannot place, rather than emitting a model with elements missing. ## The API element form +An explicitly named API element-form `.json` file is converted to SysML notation before it is +loaded or validated. Diagnostic positions refer to that converted notation, not to positions in +the JSON document. + `sysml -convert api-json` (`%save model.json`, the service's `Convert` to or from `api-json` or `json`) writes the graph above in the form the OMG SysML v2 API & Services specification serves from its `/elements` endpoints: a JSON array of diff --git a/internal/frontend/grpc/cache.go b/internal/frontend/grpc/cache.go index 085ada8f63..052e84a883 100644 --- a/internal/frontend/grpc/cache.go +++ b/internal/frontend/grpc/cache.go @@ -33,6 +33,7 @@ type CachedDocument struct { // document's: the parse's errors and warnings as the passes present them, // and the passes' own findings when the model parsed clean and was analyzed. Diagnostics []diag.Diagnostic + Warnings []string } // CachedModel holds parsed model data with semantic analysis results diff --git a/internal/frontend/grpc/service.go b/internal/frontend/grpc/service.go index a05ebe2216..8506086fd6 100644 --- a/internal/frontend/grpc/service.go +++ b/internal/frontend/grpc/service.go @@ -21,6 +21,7 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/syntax/diag" "github.com/Open-MBEE/OpenSysML/internal/syntax/parser" "github.com/Open-MBEE/OpenSysML/internal/syntax/source" + "github.com/Open-MBEE/OpenSysML/internal/translate/convert" ) // msgModelNotFound formats the not-found status for an unknown model hash. @@ -607,6 +608,7 @@ type sourceInput struct { language string content string kind source.Kind + warnings []string } // ParseFile parses a SysML file and caches the result @@ -731,7 +733,20 @@ func fileInput(path string) (sourceInput, error) { if err != nil { return sourceInput{}, statusErrorf(connect.CodeNotFound, "file not found: %v", err) } - return sourceInput{name: path, content: string(data), kind: source.KindOf(path)}, nil + var warnings []string + text, converted, err := convert.ModelSource(path, data, func(message string) { + warnings = append(warnings, message) + }) + if err != nil { + return sourceInput{}, statusError(connect.CodeInvalidArgument, err.Error()) + } + kind := source.KindOf(path) + if converted { + kind = source.KindSysML + } + return sourceInput{ + name: path, content: string(text), kind: kind, warnings: warnings, + }, nil } // parseModel parses the documents into one model and caches it, or returns the @@ -756,6 +771,10 @@ func (s *Service) parseModel(inputs []sourceInput, mode diag.ConformanceMode) (s for _, field := range []string{input.name, input.language, input.content} { fmt.Fprintf(&key, "\x00%d\x00%s", len(field), field) } + fmt.Fprintf(&key, "\x00%d", len(input.warnings)) + for _, warning := range input.warnings { + fmt.Fprintf(&key, "\x00%d\x00%s", len(warning), warning) + } } modelHash := computeHash(key.String()) if cached, ok := s.cache.Get(modelHash); ok { @@ -783,6 +802,7 @@ func (s *Service) parseModel(inputs []sourceInput, mode diag.ConformanceMode) (s Source: srcFile, ParseDiags: p.Diagnostics, Diagnostics: parser.AsDiagnostics(p.Diagnostics, p.Warnings), + Warnings: append([]string(nil), input.warnings...), }) } @@ -856,6 +876,13 @@ func (s *Service) modelDiagnostics(model *CachedModel) []*pb.Diagnostic { for _, diag := range doc.Diagnostics { pbDiags = append(pbDiags, DiagnosticToProto(diag, doc.Source)) } + for _, warning := range doc.Warnings { + pbDiags = append(pbDiags, &pb.Diagnostic{ + Severity: diag.SeverityWarning.String(), + Message: warning, + Span: &pb.Span{File: doc.Source.Name()}, + }) + } } return s.filterDiagnosticCapabilities(pbDiags) } diff --git a/internal/frontend/grpc/service_test.go b/internal/frontend/grpc/service_test.go index 468a6e2008..46c29055a6 100644 --- a/internal/frontend/grpc/service_test.go +++ b/internal/frontend/grpc/service_test.go @@ -5,8 +5,10 @@ import ( "os" "path/filepath" "slices" + "strings" "testing" + "connectrpc.com/connect" pb "github.com/Open-MBEE/OpenSysML/api/proto" ) @@ -106,6 +108,76 @@ package Vehicle { } } +func TestParseFileAPIJSONPathReturnsRootAndWarning(t *testing.T) { + path, err := filepath.Abs(filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json")) + if err != nil { + t.Fatal(err) + } + srv := mustNewService(t, 10) + + resp, err := srv.ParseFile(context.Background(), &pb.ParseFileRequest{ + Source: &pb.ParseFileRequest_FilePath{FilePath: path}, + }) + if err != nil { + t.Fatalf("ParseFile failed: %v", err) + } + if resp.Root == nil || len(resp.Root.ChildIds) == 0 { + t.Fatalf("ParseFile returned no root symbols: %+v", resp.Root) + } + var warning *pb.Diagnostic + for _, diagnostic := range resp.Diagnostics { + if diagnostic.Severity == "warning" && strings.Contains(diagnostic.Message, "library element") { + warning = diagnostic + break + } + } + if warning == nil { + t.Fatalf("ParseFile returned no library identity warning: %v", resp.Diagnostics) + } + if warning.Span == nil || warning.Span.File != path { + t.Fatalf("warning span = %+v, want JSON file %q", warning.Span, path) + } + if warning.Span.StartLine != 0 || warning.Span.StartCol != 0 || + warning.Span.EndLine != 0 || warning.Span.EndCol != 0 { + t.Fatalf("warning unexpectedly has a source range: %+v", warning.Span) + } + + diagnostics, err := srv.GetDiagnostics(context.Background(), &pb.DiagnosticsRequest{ModelHash: resp.ModelHash}) + if err != nil { + t.Fatalf("GetDiagnostics failed: %v", err) + } + if len(diagnostics.Diagnostics) != len(resp.Diagnostics) { + t.Fatalf("cached diagnostics = %d, ParseFile diagnostics = %d", + len(diagnostics.Diagnostics), len(resp.Diagnostics)) + } + cachedWarning := false + for _, diagnostic := range diagnostics.Diagnostics { + if diagnostic.Severity == warning.Severity && diagnostic.Message == warning.Message && + diagnostic.Span != nil && diagnostic.Span.File == path { + cachedWarning = true + break + } + } + if !cachedWarning { + t.Fatalf("cached diagnostics omitted the API JSON warning: %v", diagnostics.Diagnostics) + } +} + +func TestParseFileUnconvertibleAPIJSONIsInvalidArgument(t *testing.T) { + path, err := filepath.Abs(filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_unmatched.toolkit.full.json")) + if err != nil { + t.Fatal(err) + } + srv := mustNewService(t, 10) + + _, err = srv.ParseFile(context.Background(), &pb.ParseFileRequest{ + Source: &pb.ParseFileRequest_FilePath{FilePath: path}, + }) + if err == nil || connect.CodeOf(err) != connect.CodeInvalidArgument { + t.Fatalf("ParseFile error = %v, want InvalidArgument", err) + } +} + func TestParseFile_InlineKerMLUsesImplicitLibraryBases(t *testing.T) { srv := mustNewService(t, 10) resp, err := srv.ParseFile(context.Background(), &pb.ParseFileRequest{ diff --git a/internal/frontend/repl/load.go b/internal/frontend/repl/load.go index 888ccd116b..dfa0b8c9a8 100644 --- a/internal/frontend/repl/load.go +++ b/internal/frontend/repl/load.go @@ -5,6 +5,7 @@ import ( "fmt" "io/fs" + "github.com/Open-MBEE/OpenSysML/internal/translate/convert" "github.com/Open-MBEE/OpenSysML/internal/workspace/project" ) @@ -65,9 +66,23 @@ func (s *Session) loadPathsReport(paths []string) (LoadReport, error) { } } found, declared := renderSplit(s.submitFiles(srcs), s.verbosity) + found = append(found, conversionWarnings(srcs, s.verbosity)...) return LoadReport{Loaded: loaded, Found: found, Declared: declared, Errors: s.hasAnalysisErrors()}, nil } +func conversionWarnings(files []SourceFile, verbosity Verbosity) []string { + if verbosity <= VerbosityQuiet { + return nil + } + var lines []string + for _, file := range files { + for _, warning := range file.Warnings { + lines = append(lines, "warning: "+warning) + } + } + return lines +} + // ExpandPaths turns the paths a caller was given — files, directories to walk // for .sysml/.kerml files, or glob patterns — into the model files to load, in a // deterministic order and without duplicates. @@ -109,7 +124,14 @@ func (s *Session) readSources(paths []string) ([]SourceFile, error) { if err := reservedName(name); err != nil { return nil, err } - files = append(files, SourceFile{Name: name, Text: string(data)}) + var warnings []string + text, _, err := convert.ModelSource(name, data, func(message string) { + warnings = append(warnings, message) + }) + if err != nil { + return nil, fmt.Errorf("cannot convert %s: %w", name, err) + } + files = append(files, SourceFile{Name: name, Text: string(text), Warnings: warnings}) } return files, nil } diff --git a/internal/frontend/repl/load_test.go b/internal/frontend/repl/load_test.go index b91bc5a08b..3a4675a355 100644 --- a/internal/frontend/repl/load_test.go +++ b/internal/frontend/repl/load_test.go @@ -43,6 +43,7 @@ func TestLoadingADirectoryResolvesRegardlessOfFileName(t *testing.T) { // Sorted order puts the referencing file first. writeFile(t, filepath.Join(dir, "a-uses.sysml"), "package Uses { private import Defs::*; part w : Wheel; }\n") writeFile(t, filepath.Join(dir, "b-defs.sysml"), "package Defs { part def Wheel; }\n") + writeFile(t, filepath.Join(dir, "ignored.json"), "not API JSON") s := NewSession() out, err := s.LoadPaths([]string{dir}) @@ -61,6 +62,40 @@ func TestLoadingADirectoryResolvesRegardlessOfFileName(t *testing.T) { } } +func TestLoadPathsReportConvertsAPIJSONAndReportsWarnings(t *testing.T) { + path := filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json") + session := NewSession() + + report, err := session.LoadPathsReport([]string{path}) + if err != nil { + t.Fatal(err) + } + if report.Errors { + t.Fatalf("converted API JSON did not analyze cleanly: %v", report.Found) + } + if len(report.Declared) == 0 { + t.Fatal("converted API JSON declared no root symbols") + } + if !strings.Contains(strings.Join(report.Found, "\n"), "warning: the library element") { + t.Fatalf("load report omitted the conversion warning: %v", report.Found) + } +} + +func TestLoadingADirectoryIgnoresJSONFiles(t *testing.T) { + dir := t.TempDir() + writeFile(t, filepath.Join(dir, "model.sysml"), "package OnlySysML { part def A; }\n") + writeFile(t, filepath.Join(dir, "not-a-model.json"), "not API JSON") + + session := NewSession() + report, err := session.LoadPathsReport([]string{dir}) + if err != nil { + t.Fatal(err) + } + if report.Errors || len(report.Declared) != 1 || !strings.Contains(report.Declared[0], "OnlySysML") { + t.Fatalf("directory load did not ignore .json: %+v", report) + } +} + func TestMetaLoadAcceptsADirectory(t *testing.T) { dir := t.TempDir() writeFile(t, filepath.Join(dir, "a.sysml"), "package A { }\n") diff --git a/internal/frontend/repl/run.go b/internal/frontend/repl/run.go index db0c26592d..3b38e8f872 100644 --- a/internal/frontend/repl/run.go +++ b/internal/frontend/repl/run.go @@ -61,7 +61,8 @@ func (s *Session) LoadFile(path string) ([]string, error) { if err != nil { return nil, err } - return renderResult(s.submitFiles(files), s.verbosity), nil + lines := renderResult(s.submitFiles(files), s.verbosity) + return append(lines, conversionWarnings(files, s.verbosity)...), nil } // LoadFileSummary submits the contents of path and returns only what it @@ -91,6 +92,7 @@ func (s *Session) LoadFilesSummary(paths []string) ([]string, error) { own := res.within(s.fileSpan(f.Name)) lines = append(lines, renderSyntax(own, s.verbosity)...) lines = append(lines, byFile[i]...) + lines = append(lines, conversionWarnings([]SourceFile{f}, s.verbosity)...) if i == 0 { lines = append(lines, whole...) } diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go index 1330925002..df57e04e0a 100644 --- a/internal/frontend/repl/session.go +++ b/internal/frontend/repl/session.go @@ -835,8 +835,9 @@ func (s *Session) Submit(src string) Result { // SourceFile is one source of a submission together with the file it was read // from, which is what diagnostics over a multi-file load are reported against. type SourceFile struct { - Name string - Text string + Name string + Text string + Warnings []string } // SubmitAll accumulates every src as one submission, from no file in particular. diff --git a/internal/syntax/source/kind.go b/internal/syntax/source/kind.go index 01f50218dd..5ffc76ec57 100644 --- a/internal/syntax/source/kind.go +++ b/internal/syntax/source/kind.go @@ -1,8 +1,11 @@ package source -import "strings" +import ( + "path/filepath" + "strings" +) -// Kind is the language a file is written in. The two languages share a lexer +// Kind is the language a source is parsed as. The two languages share a lexer // but not a grammar: KerML notation in a SysML file is diagnosed. type Kind int @@ -27,12 +30,13 @@ func (k Kind) String() string { } } -// KindOf reports the language of a file name by its extension. +// KindOf reports the language of a file name by its extension. API JSON files +// are converted to SysML notation before they are parsed. func KindOf(name string) Kind { - switch { - case strings.HasSuffix(name, ".sysml"): + switch strings.ToLower(filepath.Ext(name)) { + case ".sysml", ".json": return KindSysML - case strings.HasSuffix(name, ".kerml"): + case ".kerml": return KindKerML default: return KindUnknown diff --git a/internal/syntax/source/source_test.go b/internal/syntax/source/source_test.go index 95116075da..f4d6eca27d 100644 --- a/internal/syntax/source/source_test.go +++ b/internal/syntax/source/source_test.go @@ -2,6 +2,14 @@ package source import "testing" +func TestKindOfAPIJSONIsSysML(t *testing.T) { + for _, name := range []string{"model.json", "model.JSON"} { + if got := KindOf(name); got != KindSysML { + t.Errorf("KindOf(%q) = %v, want SysML", name, got) + } + } +} + func TestSpanText(t *testing.T) { sf := New("test.sysml", []byte("part def Engine;")) sp := Span{Offset: 9, Len: 6} diff --git a/internal/translate/convert/convert.go b/internal/translate/convert/convert.go index 0fca4be961..51f253086d 100644 --- a/internal/translate/convert/convert.go +++ b/internal/translate/convert/convert.go @@ -174,6 +174,20 @@ func FormatOfPath(path string) (Format, error) { } } +// ModelSource converts an explicitly named API-JSON source to SysML notation. +// Other formats are returned unchanged. +func ModelSource(name string, data []byte, warn func(string)) (text []byte, converted bool, err error) { + from, err := FormatOfPath(name) + if err != nil || from != FormatAPIJSON { + return data, false, nil + } + text, err = ConvertWith(name, data, FormatAPIJSON, FormatSysML, Options{Warn: warn}) + if err != nil { + return nil, false, err + } + return text, true, nil +} + // SyntaxError reports that the input could not be read as its format. It lists // every syntax error rather than only the first, so one conversion attempt // shows everything that needs fixing. diff --git a/internal/translate/convert/model_source_test.go b/internal/translate/convert/model_source_test.go new file mode 100644 index 0000000000..a3600a81a6 --- /dev/null +++ b/internal/translate/convert/model_source_test.go @@ -0,0 +1,44 @@ +package convert + +import ( + "os" + "path/filepath" + "strings" + "testing" +) + +func TestModelSourceConvertsAPIJSONAndReturnsWarnings(t *testing.T) { + path := filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json") + data, err := os.ReadFile(path) + if err != nil { + t.Fatal(err) + } + + var warnings []string + text, converted, err := ModelSource(path, data, func(message string) { + warnings = append(warnings, message) + }) + if err != nil { + t.Fatal(err) + } + if !converted { + t.Fatal("API JSON was not marked converted") + } + if !strings.Contains(string(text), "library package DocumentLibrary") { + t.Fatalf("converted source does not contain the document-defined library package:\n%s", text) + } + if len(warnings) == 0 { + t.Fatal("expected a warning for the stale library identity") + } +} + +func TestModelSourceLeavesOtherFormatsUnchanged(t *testing.T) { + data := []byte("not a model") + text, converted, err := ModelSource("model.sysml", data, nil) + if err != nil { + t.Fatal(err) + } + if converted || string(text) != string(data) { + t.Fatalf("ModelSource returned %q, converted=%t; want the original bytes", text, converted) + } +} From 7076103c227c41890899a14fb3a196e68c2149d7 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 01:47:51 +0000 Subject: [PATCH 03/10] fix(export): preserve toolkit API JSON round trips Co-Authored-By: jason.han --- .../unreleased/toolkit-json-import.fixed.md | 1 + docs/reference/rdf-mapping.md | 11 + internal/translate/convert/convert.go | 8 + .../translate/export/api_json_import_test.go | 209 + internal/translate/export/api_json_in.go | 348 +- internal/translate/export/behavior.go | 2 + internal/translate/export/end_forms.go | 30 +- internal/translate/export/rdf_in.go | 48 +- internal/translate/export/rdf_in_normative.go | 40 +- internal/translate/export/rdf_in_toolkit.go | 62 +- internal/translate/export/rdf_normative.go | 35 + .../translate/export/rdf_normative_test.go | 57 + internal/translate/export/root_namespace.go | 21 +- internal/translate/rdf/graph_fastpath_test.go | 159 + internal/translate/rdf/term.go | 301 +- internal/translate/rdf/turtle_write.go | 4 +- tests/export/testdata/interchange/README.md | 2 + .../testdata/interchange/satisfy_by.sysml | 11 + .../interchange/satisfy_by.toolkit.full.json | 3627 +++++++++++++++++ tests/export/toolkit_json_import_test.go | 40 + 20 files changed, 4853 insertions(+), 163 deletions(-) create mode 100644 tests/export/testdata/interchange/satisfy_by.sysml create mode 100644 tests/export/testdata/interchange/satisfy_by.toolkit.full.json diff --git a/changes/unreleased/toolkit-json-import.fixed.md b/changes/unreleased/toolkit-json-import.fixed.md index 6eb27745be..84dd648e2d 100644 --- a/changes/unreleased/toolkit-json-import.fixed.md +++ b/changes/unreleased/toolkit-json-import.fixed.md @@ -1 +1,2 @@ - **Toolkit full-JSON imports preserve flows, transitions, and library references.** Flow ends owned through `EndFeatureMembership` are folded into the flow head; transitions read trigger, guard, and effect features by their membership kind rather than mistaking parameters for effects; and document-defined library packages remain declarations. Library stubs with stale ids can resolve by their stated qualified name or graph-stated name and owner chain, with a warning, while unmatched identities report both the id and name. Apollo API-JSON import avoids rescanning the whole graph for each owner. +- Reference-usage return parameters retain their metaclass on toolkit JSON round trips. Bulk API JSON decoding delays duplicate indexing until parsing is complete, and graph normalization reuses the imported graph's storage while releasing excess triple capacity. diff --git a/docs/reference/rdf-mapping.md b/docs/reference/rdf-mapping.md index 0891707c39..8133a9d58e 100644 --- a/docs/reference/rdf-mapping.md +++ b/docs/reference/rdf-mapping.md @@ -570,6 +570,12 @@ The `sysx:` properties: | `sysx:isKindImplicit` | The declaration wrote no kind keyword (`in x : Real;`), which takes its kind from its owner. Without it the canonical keyword would come back written out, declaring what the author did not. A kind named in a comment in the head (`in /* attribute */ x : Real;`) is trivia, not a keyword the declaration wrote. | | the behavioral properties | `sysx:guard`, `sysx:expression`, `sysx:payload`, … — the parts of a behavioral node the vocabulary has no predicate for, listed under [Behavior](#behavior). | +A `return` parameter written without a kind keyword is a `ReferenceUsage` +owned through a `ReturnParameterMembership`. OpenSysML-authored graphs retain +`sysx:isKindImplicit` for this form. The API-JSON reader supplies that marker +for a toolkit `ReferenceUsage` result with no `sysx:declaredKeyword`, so it also +writes the return without a kind keyword. + For expressions and end-binding heads, the encoder still emits these `sysx:` terms. They carry notation or ordering facts for which the 202407 metamodel has no property; they are annotations, not replacements for the standard shape: @@ -1677,6 +1683,11 @@ is a synonym for the kind (`allocate` for an allocation) it is carried as `sysml:RequirementUsage` a `sysml:RequirementVerificationMembership` owns, with `sysml:kind "requirement"` (SysML-textual-bnf RequirementVerificationMember). +For `satisfy R by a.b`, the subject parameter's value is a +`FeatureReferenceExpression` whose `referent` is an owned chain `Feature`. +The chain is the `FeatureChainMember` in SysML.xtext's +`SatisfactionReferenceExpression` grammar, rather than expression text. + An anonymous connector's own multiplicity (`sysml:lowerBound`/`sysml:upperBound` on the connector, as against on an end node) is its declaration, and is written ahead of the ends: `succession [n] first a then b`, `binding [1] of a = b`. A diff --git a/internal/translate/convert/convert.go b/internal/translate/convert/convert.go index 51f253086d..b0edb24795 100644 --- a/internal/translate/convert/convert.go +++ b/internal/translate/convert/convert.go @@ -342,6 +342,14 @@ func convert(name string, data []byte, from, to Format, tolerateSyntaxErrors boo return out, nil, err case from == FormatAPIJSON: + if to == FormatSysML { + out, err := export.APIJSONToSysML(data, opts.Warn) + var readErr *export.APIJSONReadError + if errors.As(err, &readErr) { + return nil, nil, &SyntaxError{Name: name, Messages: []string{readErr.Error()}} + } + return out, nil, err + } // The input is the API element form; api-json to api-json normalizes it // as Turtle to Turtle does. graph, err := readAPIJSON(name, data) diff --git a/internal/translate/export/api_json_import_test.go b/internal/translate/export/api_json_import_test.go index 80b6be0e6b..1e6f642d3d 100644 --- a/internal/translate/export/api_json_import_test.go +++ b/internal/translate/export/api_json_import_test.go @@ -6,7 +6,9 @@ import ( "fmt" "os" "path/filepath" + "reflect" "regexp" + "slices" "strings" "testing" @@ -75,6 +77,25 @@ func TestToolkitAPIJSONDecodes(t *testing.T) { } } +func TestToSysMLDoesNotMutateTurtleGraph(t *testing.T) { + graph, err := ReadAPIJSON(interchangeFixture(t, "flow_ends.toolkit.full.json")) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + turtle := rdf.WriteTurtle(graph) + graph, err = rdf.ParseTurtle(turtle) + if err != nil { + t.Fatalf("ParseTurtle: %v", err) + } + before := slices.Clone(graph.Triples()) + if _, err := ToSysML(graph); err != nil { + t.Fatalf("ToSysML: %v", err) + } + if after := graph.Triples(); !slices.Equal(after, before) { + t.Fatalf("ToSysML changed the Turtle graph triples: before %d, after %d", len(before), len(after)) + } +} + // TestToolkitAPIGoldenNotation pins the notation the toolkit's interchange // decodes to. func TestToolkitAPIGoldenNotation(t *testing.T) { @@ -85,6 +106,194 @@ func TestToolkitAPIGoldenNotation(t *testing.T) { } } +func TestToolkitSatisfyByKeepsFeatureReferenceExpression(t *testing.T) { + input := interchangeFixture(t, "satisfy_by.toolkit.full.json") + notation := decodeAPIJSON(t, input) + if !bytes.Contains(notation, []byte("satisfy mission by vehicle.engine;")) { + t.Fatalf("the satisfy subject was not written as a `by` reference:\n%s", notation) + } + file := source.New("satisfy_by.sysml", notation) + p := parser.New(file) + root := p.ParseFile() + if len(p.Diagnostics) != 0 { + t.Fatalf("the decoded notation does not parse: %v", p.Diagnostics) + } + graph, err := ToRDF(file, root) + if err != nil { + t.Fatalf("ToRDF: %v", err) + } + reexported, err := WriteAPIJSON(graph) + if err != nil { + t.Fatalf("WriteAPIJSON: %v", err) + } + before, after := countTable(t, input), countTable(t, reexported) + for _, metaclass := range []string{"FeatureChainExpression", "FeatureChaining", "FeatureReferenceExpression"} { + if before[metaclass] != after[metaclass] { + t.Errorf("%s count changed: before %d, after %d", metaclass, before[metaclass], after[metaclass]) + } + } +} + +func TestReturnUsageKeepsItsMetaclass(t *testing.T) { + for _, tc := range []struct { + name string + src string + toolkit bool + wantReference bool + byteIdentical bool + expectedNotation string + }{ + { + name: "default usage", + src: "package R {\n calc def F {\n return x : Real;\n }\n}\n", + byteIdentical: true, + expectedNotation: "return x : Real", + }, + { + name: "reference usage", + src: "package R { calc def F { return ref result : Real; } }", + toolkit: true, + wantReference: true, + expectedNotation: "return ref result : Real", + }, + { + name: "anonymous reference usage", + src: "package R { calc def F { in value : Real; return :> value = value; } }", + toolkit: true, + wantReference: true, + expectedNotation: "return :> value = value", + }, + } { + t.Run(tc.name, func(t *testing.T) { + file := source.New("return.sysml", []byte(tc.src)) + p := parser.New(file) + root := p.ParseFile() + if len(p.Diagnostics) > 0 { + t.Fatalf("the fixture does not parse: %v", p.Diagnostics) + } + graph, err := ToRDF(file, root) + if err != nil { + t.Fatalf("ToRDF: %v", err) + } + ownText, err := ToSysML(graph) + if err != nil { + t.Fatalf("ToSysML native graph: %v", err) + } + if tc.byteIdentical && !bytes.Equal(ownText, []byte(tc.src)) { + t.Fatalf("native notation is not byte-identical:\n--- want ---\n%s\n--- got ---\n%s", tc.src, ownText) + } + ownFile := source.New("return.sysml", ownText) + ownParser := parser.New(ownFile) + ownRoot := ownParser.ParseFile() + if len(ownParser.Diagnostics) > 0 { + t.Fatalf("the native round-trip notation does not parse: %v\n%s", ownParser.Diagnostics, ownText) + } + ownGraph, err := ToRDF(ownFile, ownRoot) + if err != nil { + t.Fatalf("ToRDF native round trip: %v", err) + } + if !reflect.DeepEqual(graphWithoutSourceText(graph), graphWithoutSourceText(ownGraph)) { + t.Fatalf("native return graph changed:\n%s", string(ownText)) + } + before := resultUsageTypes(t, graph) + graphToDecode := graph + if tc.toolkit { + var triples []rdf.Triple + for _, triple := range graph.Triples() { + switch triple.Predicate.Value { + case rdf.OpenSysML + xDeclaredKeyword, + rdf.OpenSysML + xSourceText, + rdf.OpenSysML + xSourceTail, + rdf.OpenSysML + xSourceLanguage: + continue + } + triples = append(triples, triple) + } + graphToDecode = rdf.NewGraphOf(triples, graph.Prefixes) + } + out, err := ToSysML(graphToDecode) + if err != nil { + t.Fatalf("ToSysML: %v", err) + } + roundTrip := source.New("return.sysml", out) + roundParser := parser.New(roundTrip) + roundRoot := roundParser.ParseFile() + if len(roundParser.Diagnostics) > 0 { + t.Fatalf("the round-trip notation does not parse: %v\n%s", roundParser.Diagnostics, out) + } + reparsed, err := ToRDF(roundTrip, roundRoot) + if err != nil { + t.Fatalf("round-trip ToRDF: %v", err) + } + after := resultUsageTypes(t, reparsed) + if !reflect.DeepEqual(before, after) { + t.Fatalf("result metaclasses changed: before %v, after %v\n%s", before, after, out) + } + if len(before) != 1 { + t.Fatalf("result metaclasses = %v, want one metaclass", before) + } + if tc.wantReference && before["ReferenceUsage"] != 1 { + t.Fatalf("result metaclasses = %v, want ReferenceUsage", before) + } + if tc.expectedNotation != "" && !bytes.Contains(out, []byte(tc.expectedNotation)) { + t.Fatalf("the return form is missing %q:\n%s", tc.expectedNotation, out) + } + if tc.toolkit { + toolkitNotation := out + if !bytes.Contains(toolkitNotation, []byte(tc.expectedNotation)) { + t.Fatalf("the toolkit ReferenceUsage return was not written with its reference semantics:\n%s", toolkitNotation) + } + toolkitFile := source.New("return.sysml", toolkitNotation) + toolkitParser := parser.New(toolkitFile) + toolkitRoot := toolkitParser.ParseFile() + if len(toolkitParser.Diagnostics) > 0 { + t.Fatalf("the toolkit return notation does not parse: %v\n%s", toolkitParser.Diagnostics, toolkitNotation) + } + toolkitGraph, err := ToRDF(toolkitFile, toolkitRoot) + if err != nil { + t.Fatalf("toolkit return ToRDF: %v", err) + } + if got := resultUsageTypes(t, toolkitGraph); !reflect.DeepEqual(got, map[string]int{"ReferenceUsage": 1}) { + t.Fatalf("toolkit return metaclasses = %v, want ReferenceUsage", got) + } + } + }) + } +} + +func graphWithoutSourceText(graph *rdf.Graph) map[rdf.Triple]bool { + out := make(map[rdf.Triple]bool, graph.Len()) + for _, triple := range graph.Triples() { + switch triple.Predicate.Value { + case rdf.OpenSysML + xSourceText, rdf.OpenSysML + xSourceTail, rdf.OpenSysML + xSourceLanguage: + continue + } + out[triple] = true + } + return out +} + +func resultUsageTypes(t *testing.T, graph *rdf.Graph) map[string]int { + t.Helper() + data, err := WriteAPIJSON(graph) + if err != nil { + t.Fatalf("WriteAPIJSON: %v", err) + } + var objects []map[string]any + if err := json.Unmarshal(data, &objects); err != nil { + t.Fatalf("decode API JSON: %v", err) + } + types := map[string]int{} + for _, object := range objects { + if object["isResult"] == true { + if kind, ok := object["@type"].(string); ok { + types[kind]++ + } + } + } + return types +} + // TestToolkitRootTransparent checks the toolkit's root Namespace wrapper does // not decode as a member of its own. func TestToolkitRootTransparent(t *testing.T) { diff --git a/internal/translate/export/api_json_in.go b/internal/translate/export/api_json_in.go index 28bd5bb65b..b1cd7a8d5b 100644 --- a/internal/translate/export/api_json_in.go +++ b/internal/translate/export/api_json_in.go @@ -21,49 +21,74 @@ import ( // same elements back; the unnamed root Namespace a document wraps its // top-level elements in is dropped, as the Turtle form does not carry it. func ReadAPIJSON(data []byte) (*rdf.Graph, error) { - elements, expressionIDs, err := parseAPIJSON(data) + expressionIDs, elementCount, err := apiJSONExpressionIDs(data) if err != nil { return nil, err } - graph := rdf.NewGraph() + builder := rdf.NewGraphBuilder(elementCount * apiJSONEstimatedTriplesPerElement) + cache := newAPIJSONTermCache() // The collection annotations are stated after every element's triples, the // positions AnnotateCollections writes them in. var annotations []apiJSONAnnotation - for _, element := range elements { + err = apiJSONElementsOf(data, apiJSONObjectOf, func(element apiJSONElementData) error { var subject rdf.Term - if element.expression { + if expressionIDs[element.id] { subject = rdf.IRI(rdf.Expression + element.id) } else { subject = rdf.ReferenceIRI(rdf.Term{}, element.id) } - typ, err := apiJSONTypeIRI(element.typ) + typ, err := cache.typeIRI(element.typ) if err != nil { - return nil, fmt.Errorf("element %q: %w", element.id, err) + return fmt.Errorf("element %q: %w", element.id, err) } - graph.Add(subject, rdf.IRI(rdf.RDFType), typ) + builder.Add(subject, rdf.IRI(rdf.RDFType), typ) for _, member := range element.members { - predicate, sysmlKey, err := apiJSONPredicate(member.key) + predicate, sysmlKey, err := cache.predicate(member.key) if err != nil { - return nil, fmt.Errorf("element %q: %w", element.id, err) + return fmt.Errorf("element %q: %w", element.id, err) } - if err := apiJSONTriples(graph, subject, predicate, sysmlKey, member.value, expressionIDs, &annotations); err != nil { - return nil, fmt.Errorf("element %q: %w", element.id, err) + if err := apiJSONTriples(builder, subject, predicate, sysmlKey, member.value, expressionIDs, cache, &annotations); err != nil { + return fmt.Errorf("element %q: %w", element.id, err) } } + return nil + }) + if err != nil { + return nil, err } for _, annotation := range annotations { text, err := rdf.CollectionJSON(annotation.subject, annotation.members) if err != nil { return nil, err } - graph.Add(annotation.subject, rdf.AnnotationJSONTerm(annotation.key), rdf.String(text)) + builder.Add(annotation.subject, rdf.AnnotationJSONTerm(annotation.key), rdf.String(text)) } if len(expressionIDs) > 0 { - graph.Prefixes[rdf.ExpressionPrefix] = rdf.Expression + builder.SetPrefix(rdf.ExpressionPrefix, rdf.Expression) } + graph := builder.Build() return withoutRootNamespace(graph), nil } +// APIJSONReadError reports a failure to parse an API element document. +type APIJSONReadError struct { + err error +} + +func (e *APIJSONReadError) Error() string { + if e == nil || e.err == nil { + return "cannot read the API element document" + } + return e.err.Error() +} + +func (e *APIJSONReadError) Unwrap() error { + if e == nil { + return nil + } + return e.err +} + // apiJSONElementData is one parsed element object: its identity, its class as // an expression node, and its properties in written order. type apiJSONElementData struct { @@ -72,64 +97,73 @@ type apiJSONElementData struct { expression bool qualifiedName bool members []apiJSONMember + indexMember string + indexOwner string } var apiJSONInteger = regexp.MustCompile(`^-?[0-9]+$`) -// parseAPIJSON decodes the document into element objects, preserving member -// order, and returns the ids classified into the expression namespace, since -// references resolve against the whole document. -func parseAPIJSON(data []byte) ([]apiJSONElementData, map[string]bool, error) { - objects, err := apiJSONObjectsOf(data) - if err != nil { - return nil, nil, err +const apiJSONEstimatedTriplesPerElement = 10 + +// apiJSONExpressionIDs indexes the element identities in a first pass, so the +// second pass can stream their properties directly into the graph. +func apiJSONExpressionIDs(data []byte) (map[string]bool, int, error) { + var objects []apiJSONElementData + if err := apiJSONElementsOf(data, apiJSONIndexObjectOf, func(object apiJSONElementData) error { + objects = append(objects, object) + return nil + }); err != nil { + return nil, 0, err } index, err := newAPIJSONIndex(objects) if err != nil { - return nil, nil, err + return nil, 0, err } index.classifyExpressions(objects) - return objects, index.expressionIDs, nil + return index.expressionIDs, len(objects), nil } -// apiJSONObjectsOf decodes the document's element objects: an array of them -// or a single object, and nothing after it. -func apiJSONObjectsOf(data []byte) ([]apiJSONElementData, error) { +// apiJSONElementsOf visits each element object in either supported document +// shape, rejecting trailing JSON values. +func apiJSONElementsOf(data []byte, read func(*json.Decoder) (apiJSONElementData, error), visit func(apiJSONElementData) error) error { dec := json.NewDecoder(bytes.NewReader(data)) dec.UseNumber() start, err := dec.Token() if err != nil { - return nil, fmt.Errorf("cannot read the API element document: %w", err) + return fmt.Errorf("cannot read the API element document: %w", err) } - var objects []apiJSONElementData switch start { case json.Delim('['): for dec.More() { if token, err := dec.Token(); err != nil || token != json.Delim('{') { - return nil, fmt.Errorf("an API element array holds element objects, not %v", token) + return fmt.Errorf("an API element array holds element objects, not %v", token) } - object, err := apiJSONObjectOf(dec) + object, err := read(dec) if err != nil { - return nil, err + return err + } + if err := visit(object); err != nil { + return err } - objects = append(objects, object) } if _, err := dec.Token(); err != nil { - return nil, fmt.Errorf("cannot read the API element array: %w", err) + return fmt.Errorf("cannot read the API element array: %w", err) } case json.Delim('{'): - object, err := apiJSONObjectOf(dec) + object, err := read(dec) if err != nil { - return nil, err + return err + } + if err := visit(object); err != nil { + return err } - objects = append(objects, object) default: - return nil, fmt.Errorf("an API element document is an array of element objects or a single object, not %v", start) + return fmt.Errorf("an API element document is an array of element objects or a single object, not %v", start) } if _, err := dec.Token(); err != io.EOF { - return nil, fmt.Errorf("the API element document holds more than one JSON value") + return fmt.Errorf("the API element document holds more than one JSON value") } - return objects, nil + return nil } // apiJSONIndex is what classifying the expression namespace reads across the @@ -173,17 +207,7 @@ func newAPIJSONIndex(objects []apiJSONElementData) (*apiJSONIndex, error) { // Opaque ids such as UUIDs carry no parent, so the membership that states // the node as its member stands in. for _, object := range objects { - member, owner := "", "" - for _, m := range object.members { - id, isRef := memberReference(m.value) - switch { - case !isRef: - case membershipMemberProperty(m.key): - member = id - case membershipOwnerProperty(m.key): - owner = id - } - } + member, owner := object.indexMember, object.indexOwner if owner != "" && isRelationship(object.typ) { index.relationshipOwner[object.id] = owner } @@ -304,6 +328,110 @@ func memberReference(value any) (string, bool) { // apiJSONObjectOf reads one '{...}' from the decoder — its '{' already consumed // — returning "@type"/"@id" extracted and the other members in written order. +func apiJSONIndexObjectOf(dec *json.Decoder) (apiJSONElementData, error) { + object := apiJSONElementData{} + seen := map[string]bool{} + for dec.More() { + token, err := dec.Token() + if err != nil { + return object, err + } + key, ok := token.(string) + if !ok { + return object, fmt.Errorf("an element object's member key is a string, not %v", token) + } + if seen[key] { + return object, fmt.Errorf("element object states %q twice", key) + } + seen[key] = true + switch { + case key == "@type", key == "@id": + value, err := apiJSONValueOf(dec) + if err != nil { + return object, fmt.Errorf("%s: %w", key, err) + } + text, ok := value.(string) + if !ok { + return object, fmt.Errorf("%q is a string, not %v", key, value) + } + if key == "@type" { + object.typ = text + } else { + object.id = text + } + case strings.HasPrefix(key, "@"): + return object, fmt.Errorf("the key %q is not a keyword this document carries", key) + case key == "qualifiedName": + value, err := apiJSONValueOf(dec) + if err != nil { + return object, fmt.Errorf("%s: %w", key, err) + } + text, ok := value.(string) + object.qualifiedName = ok && text != "" + case membershipMemberProperty(key), membershipOwnerProperty(key): + value, err := apiJSONValueOf(dec) + if err != nil { + return object, fmt.Errorf("%s: %w", key, err) + } + if id, ok := memberReference(value); ok { + if membershipMemberProperty(key) { + object.indexMember = id + } else { + object.indexOwner = id + } + } + default: + if err := skipAPIJSONValue(dec); err != nil { + return object, fmt.Errorf("%s: %w", key, err) + } + } + } + if _, err := dec.Token(); err != nil { + return object, err + } + return object, nil +} + +func skipAPIJSONValue(dec *json.Decoder) error { + token, err := dec.Token() + if err != nil { + return err + } + switch token { + case json.Delim('{'): + seen := map[string]bool{} + for dec.More() { + keyToken, err := dec.Token() + if err != nil { + return err + } + key, ok := keyToken.(string) + if !ok { + return fmt.Errorf("an object member key is a string, not %v", keyToken) + } + if seen[key] { + return fmt.Errorf("object states %q twice", key) + } + seen[key] = true + if err := skipAPIJSONValue(dec); err != nil { + return err + } + } + _, err := dec.Token() + return err + case json.Delim('['): + for dec.More() { + if err := skipAPIJSONValue(dec); err != nil { + return err + } + } + _, err := dec.Token() + return err + default: + return nil + } +} + func apiJSONObjectOf(dec *json.Decoder) (apiJSONElementData, error) { var object apiJSONElementData seen := map[string]bool{} @@ -432,6 +560,89 @@ func apiJSONPredicate(key string) (rdf.Term, string, error) { return rdf.SysMLTerm(key), key, nil } +type apiJSONPredicateValue struct { + term rdf.Term + key string +} + +type apiJSONReferenceKey struct { + scope string + id string +} + +type apiJSONTermCache struct { + types map[string]rdf.Term + predicates map[string]apiJSONPredicateValue + references map[apiJSONReferenceKey]rdf.Term + literals map[string]string +} + +func newAPIJSONTermCache() *apiJSONTermCache { + return &apiJSONTermCache{ + types: map[string]rdf.Term{}, + predicates: map[string]apiJSONPredicateValue{}, + references: map[apiJSONReferenceKey]rdf.Term{}, + literals: map[string]string{}, + } +} + +func (cache *apiJSONTermCache) literal(value string) string { + if stored, ok := cache.literals[value]; ok { + return stored + } + cache.literals[value] = value + return value +} + +func (cache *apiJSONTermCache) typeIRI(typ string) (rdf.Term, error) { + if term, ok := cache.types[typ]; ok { + return term, nil + } + term, err := apiJSONTypeIRI(typ) + if err == nil { + cache.types[typ] = term + } + return term, err +} + +func (cache *apiJSONTermCache) predicate(key string) (rdf.Term, string, error) { + if value, ok := cache.predicates[key]; ok { + return value.term, value.key, nil + } + term, local, err := apiJSONPredicate(key) + if err == nil { + cache.predicates[key] = apiJSONPredicateValue{term: term, key: local} + } + return term, local, err +} + +// referenceTarget resolves one JSON id or unresolved name to its graph term. +func (cache *apiJSONTermCache) referenceTarget(subject rdf.Term, object map[string]any, expressionIDs map[string]bool) (rdf.Term, error) { + if len(object) == 1 { + if id, ok := object["@id"].(string); ok && id != "" { + key := apiJSONReferenceKey{id: id} + if !strings.Contains(id, ":") { + if owner, ok := rdf.SubjectID(subject); ok { + key.scope, _, _ = strings.Cut(owner, ":") + } + } + if target, ok := cache.references[key]; ok { + return target, nil + } + target := rdf.ReferenceIRI(subject, id) + if targetID, ok := rdf.SubjectID(target); ok && expressionIDs[targetID] { + target = rdf.IRI(rdf.Expression + targetID) + } + cache.references[key] = target + return target, nil + } + if name, ok := object["@ref"].(string); ok && name != "" { + return rdf.String(cache.literal(name)), nil + } + } + return rdf.Term{}, fmt.Errorf("an object value is a reference {\"@id\": } or {\"@ref\": }") +} + // apiJSONAnnotation is a collection awaiting its json: literal: the members // a sysml: array stated, settled once every triple stands. type apiJSONAnnotation struct { @@ -441,22 +652,22 @@ type apiJSONAnnotation struct { } // apiJSONTriples states one property of an element object as graph triples. -func apiJSONTriples(graph *rdf.Graph, subject rdf.Term, predicate rdf.Term, sysmlKey string, value any, expressionIDs map[string]bool, annotations *[]apiJSONAnnotation) error { +func apiJSONTriples(graph *rdf.GraphBuilder, subject rdf.Term, predicate rdf.Term, sysmlKey string, value any, expressionIDs map[string]bool, cache *apiJSONTermCache, annotations *[]apiJSONAnnotation) error { switch v := value.(type) { case nil: // The API serves absent properties as null; nothing to state. return nil case map[string]any: - target, err := apiJSONReferenceTarget(subject, v, expressionIDs) + target, err := cache.referenceTarget(subject, v, expressionIDs) if err != nil { return err } graph.Add(subject, predicate, target) return nil case []any: - return apiJSONCollection(graph, subject, predicate, sysmlKey, v, expressionIDs, annotations) + return apiJSONCollection(graph, subject, predicate, sysmlKey, v, expressionIDs, cache, annotations) default: - object, err := apiJSONScalarOf(subject, predicate, sysmlKey, value, expressionIDs) + object, err := apiJSONScalarOf(subject, predicate, sysmlKey, value, expressionIDs, cache) if err != nil { return err } @@ -465,26 +676,6 @@ func apiJSONTriples(graph *rdf.Graph, subject rdf.Term, predicate rdf.Term, sysm } } -// apiJSONReferenceTarget resolves a member object into the term it names: a -// {"@id": } reference the IRI it spells from subject, a {"@ref": } -// — sysml-toolkit's spelling of a target it could not resolve — the name -// literal the mapping already writes for a name-valued reference. -func apiJSONReferenceTarget(subject rdf.Term, object map[string]any, expressionIDs map[string]bool) (rdf.Term, error) { - if len(object) == 1 { - if id, ok := object["@id"].(string); ok && id != "" { - target := rdf.ReferenceIRI(subject, id) - if targetID, ok := rdf.SubjectID(target); ok && expressionIDs[targetID] { - target = rdf.IRI(rdf.Expression + targetID) - } - return target, nil - } - if name, ok := object["@ref"].(string); ok && name != "" { - return rdf.String(name), nil - } - } - return rdf.Term{}, fmt.Errorf("an object value is a reference {\"@id\": } or {\"@ref\": }") -} - // nonuniqueCollections are the derived KerML collections declared {nonunique}: // a relationship's related elements may repeat (an association of two ends on one type). var nonuniqueCollections = map[string]bool{ @@ -494,13 +685,13 @@ var nonuniqueCollections = map[string]bool{ // apiJSONCollection states an array member: one triple per value, recording // a collection of at least two on a sysml: key for its json: annotation. -func apiJSONCollection(graph *rdf.Graph, subject rdf.Term, predicate rdf.Term, sysmlKey string, values []any, expressionIDs map[string]bool, annotations *[]apiJSONAnnotation) error { +func apiJSONCollection(graph *rdf.GraphBuilder, subject rdf.Term, predicate rdf.Term, sysmlKey string, values []any, expressionIDs map[string]bool, cache *apiJSONTermCache, annotations *[]apiJSONAnnotation) error { if len(values) == 0 { return nil } members := make([]rdf.Term, 0, len(values)) for _, value := range values { - member, err := apiJSONScalarOf(subject, predicate, sysmlKey, value, expressionIDs) + member, err := apiJSONScalarOf(subject, predicate, sysmlKey, value, expressionIDs, cache) if err != nil { return err } @@ -533,23 +724,24 @@ func apiJSONCollection(graph *rdf.Graph, subject rdf.Term, predicate rdf.Term, s // apiJSONScalarOf turns one JSON value into the term a triple holds: a // reference object an IRI, a bool or number its typed literal, a string a plain // literal — or the expression text a reference-valued property carries. -func apiJSONScalarOf(subject rdf.Term, predicate rdf.Term, sysmlKey string, value any, expressionIDs map[string]bool) (rdf.Term, error) { +func apiJSONScalarOf(subject rdf.Term, predicate rdf.Term, sysmlKey string, value any, expressionIDs map[string]bool, cache *apiJSONTermCache) (rdf.Term, error) { switch v := value.(type) { case bool: return rdf.Bool(v), nil case json.Number: - lexical := v.String() + lexical := cache.literal(v.String()) if apiJSONInteger.MatchString(lexical) { return rdf.TypedLiteral(lexical, rdf.XSD+"integer"), nil } return rdf.TypedLiteral(lexical, realDatatype(lexical)), nil case string: + v = cache.literal(v) if apiJSONIsExpressionText(sysmlKey, v) { return rdf.TypedLiteral(v, rdf.OpenSysML+dtExpression), nil } return rdf.String(v), nil case map[string]any: - return apiJSONReferenceTarget(subject, v, expressionIDs) + return cache.referenceTarget(subject, v, expressionIDs) case nil: return rdf.Term{}, fmt.Errorf("a collection member cannot be null") case []any: diff --git a/internal/translate/export/behavior.go b/internal/translate/export/behavior.go index a35c67f6be..9490b874a3 100644 --- a/internal/translate/export/behavior.go +++ b/internal/translate/export/behavior.go @@ -92,6 +92,8 @@ var libraryDone = ast.QualifiedNameOf("Actions", "Action", "done") var libraryStateStart = ast.QualifiedNameOf("States", "StateAction", "start") +var libraryTransitionLinkSource = ast.QualifiedNameOf("Actions", "TransitionAction", "transitionLinkSource") + // libraryReference is the subject of a standard library element named from // the global scope, or its name when no library is loaded. func (e *encoder) libraryReference(name *ast.QualifiedName) rdf.Term { diff --git a/internal/translate/export/end_forms.go b/internal/translate/export/end_forms.go index f2e8696d8b..dcfde3a00c 100644 --- a/internal/translate/export/end_forms.go +++ b/internal/translate/export/end_forms.go @@ -497,7 +497,7 @@ func (d *decoder) flowPayload(el *element) *element { // flowMetaclasses are the usages whose head takes an `of` clause // (SysML-textual-bnf FlowDeclaration, MessageDeclaration). -var flowMetaclasses = map[string]bool{"FlowUsage": true, "SuccessionFlowUsage": true} +var flowMetaclasses = map[string]bool{mFlowUsage: true, mSuccessionFlowUsage: true} // relatedEnds reads the ends of a head in the order they are written, each // behind the multiplicity it states, with the payload of a flow kept apart: it @@ -1028,14 +1028,17 @@ func (d *decoder) flowEndSegments(end rdf.Term, in *element) ([]rdf.Term, error) refuse := func(note string) ([]rdf.Term, error) { return nil, &UnsupportedError{What: fmt.Sprintf("the flow end <%s> of <%s>", end.Value, in.iri), Note: note} } - if d.graph.HasProperty(end, rdf.SysML+pDeclaredName) { - return refuse("it declares a name, and the `from`/`to` form writes the end by its reference chain") - } - if d.graph.HasProperty(end, rdf.SysML+pDeclaredShortName) { - return refuse("it declares a short name, and the `from`/`to` form writes the end by its reference chain") - } - if len(d.graph.Objects(end, rdf.SysML+pOwnedAnnotation)) > 0 { - return refuse("it owns annotations, which the `from`/`to` form cannot carry") + toolkitFeatures := d.toolkitFlowFeatures(end) + toolkitShape := len(toolkitFeatures) > 0 + if toolkitShape { + if d.graph.HasProperty(end, rdf.SysML+pDeclaredName) || + d.graph.HasProperty(end, rdf.SysML+pDeclaredShortName) || + len(d.graph.Objects(end, rdf.SysML+pOwnedAnnotation)) > 0 { + return refuse("it declares a name or annotations that the `from`/`to` form cannot carry") + } + if len(toolkitFeatures) != 1 { + return refuse(fmt.Sprintf("it owns %d toolkit FlowFeatures, and a flow end writes exactly one reference chain", len(toolkitFeatures))) + } } var segments []rdf.Term target, ok, err := d.standardEndTarget(end, in) @@ -1070,12 +1073,11 @@ func (d *decoder) flowEndSegments(end rdf.Term, in *element) ([]rdf.Term, error) if len(redefined) != 1 { return refuse(fmt.Sprintf("its FlowFeature redefines %d features, and a flow end names exactly one", len(redefined))) } - toolkitFeatures := d.toolkitFlowFeatures(end) - if len(toolkitFeatures) > 0 { - if len(toolkitFeatures) != 1 || len(features) != 1 || features[0] != toolkitFeatures[0] { - return refuse(fmt.Sprintf("it owns %d toolkit FlowFeatures, and a flow end writes exactly one reference chain", len(toolkitFeatures))) - } + if toolkitShape { feature := toolkitFeatures[0] + if len(features) != 1 || features[0] != feature { + return refuse("its toolkit FlowFeature is not the only feature the flow end owns") + } flowFeature, flowEnd := d.byIRI[feature.Value], d.byIRI[end.Value] if flowFeature == nil || flowEnd == nil { return refuse("its FlowFeature is not an implied ReferenceUsage owned through a FeatureMembership") diff --git a/internal/translate/export/rdf_in.go b/internal/translate/export/rdf_in.go index 22b5e8f8a5..ad4dade135 100644 --- a/internal/translate/export/rdf_in.go +++ b/internal/translate/export/rdf_in.go @@ -90,9 +90,25 @@ func ToSysML(graph *rdf.Graph) ([]byte, error) { // ToSysMLWarn converts a graph to notation and reports non-fatal resolutions. func ToSysMLWarn(graph *rdf.Graph, warn func(string)) ([]byte, error) { + return toSysML(graph, warn, false) +} + +// APIJSONToSysML reads an API element document and converts its owned graph. +func APIJSONToSysML(data []byte, warn func(string)) ([]byte, error) { + graph, err := ReadAPIJSON(data) + if err != nil { + return nil, &APIJSONReadError{err: err} + } + return toSysML(graph, warn, true) +} + +func toSysML(graph *rdf.Graph, warn func(string), owned bool) ([]byte, error) { if graph == nil || graph.Len() == 0 { return nil, &UnsupportedError{What: "an empty graph", Note: "nothing to convert"} } + if !owned { + graph = rdf.NewGraphOf(slices.Clone(graph.Triples()), graph.Prefixes) + } if err := checkExtensionNamespace(graph); err != nil { return nil, err } @@ -113,6 +129,7 @@ func ToSysMLWarn(graph *rdf.Graph, warn func(string)) ([]byte, error) { if err != nil { return nil, err } + graph.Compact() graph, err = rdf.ReconcileCollections(graph) if err != nil { var malformed *rdf.AnnotationError @@ -130,6 +147,7 @@ func ToSysMLWarn(graph *rdf.Graph, warn func(string)) ([]byte, error) { if err := checkValueFlags(graph); err != nil { return nil, err } + graph.Compact() warned := map[string]bool{} report := func(message string) { if warn != nil && !warned[message] { @@ -2122,7 +2140,8 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { // without the word, which only an explicit direction earns. words = append(words, direction) } - keyword := d.keywordOr(el, usageKeyword(kind)) + canonicalKeyword := usageKeyword(kind) + keyword := d.keywordOr(el, canonicalKeyword) // A `message` is the flow whose ends are event occurrences it owns as // parameters; their metaclass says `message` where the graph states none. if kind == ast.UsageFlow && keyword == usageKeyword(kind) { @@ -2394,6 +2413,20 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { } words = append(words, strings.Join(satisfyTargets, ", ")) skip = append(skip, ast.RelSubsets) + subjects, err := d.referenceList(el, rdf.SysML+relationshipProperty[ast.RelSubject]) + if err != nil { + return "", err + } + if len(subjects) > 1 { + return "", &UnsupportedError{ + What: fmt.Sprintf("the satisfy usage <%s>", el.iri), + Note: "its subject parameter states more than one `by` reference", + } + } + if len(subjects) == 1 { + words = append(words, "by", subjects[0]) + skip = append(skip, ast.RelSubject) + } case kind == ast.UsageSatisfy: words = append(words, "requirement") } @@ -2526,6 +2559,16 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { typedPart = "" skip = append(skip, ast.RelTyping) } + if isResult && el.metaclass == mReferenceUsage { + subsets, err := d.referenceList(el, rdf.SysML+relationshipProperty[ast.RelSubsets]) + if err != nil { + return "", err + } + if len(subsets) > 0 { + words = append(words, ":>", strings.Join(subsets, ", ")) + skip = append(skip, ast.RelSubsets) + } + } relationships, err := d.relationshipWords(el, typedPart, skip...) if err != nil { return "", err @@ -2534,8 +2577,7 @@ func (d *decoder) usageHead(el *element, kind ast.UsageKind) (string, error) { if hasEnds { // A connector's own multiplicity is its declaration, written ahead of // the ends; after them it would read as the last end's. - declared := multPart != "" || len(words) > declaredAt || - el.metaclass == mSuccession && keyword == usageKeyword(ast.UsageSuccession) + declared := multPart != "" || len(words) > declaredAt if declared && keywordAt < len(words) && words[keywordAt] == "bind" { // SysML's `bind` shorthand declares nothing; `bind [1] a = b` gives the // first end the `[1]`, so the declaration takes the `binding … bind` form. diff --git a/internal/translate/export/rdf_in_normative.go b/internal/translate/export/rdf_in_normative.go index 96df00fe83..8f6ec84a9d 100644 --- a/internal/translate/export/rdf_in_normative.go +++ b/internal/translate/export/rdf_in_normative.go @@ -870,7 +870,7 @@ func (d *decoder) headEnd(el, parent *element) bool { } if el.metaclass == mFlowEnd { switch parent.metaclass { - case "Flow", "FlowUsage", "SuccessionFlow", "SuccessionFlowUsage": + case mFlow, mFlowUsage, mSuccessionFlow, mSuccessionFlowUsage: return true } } @@ -906,28 +906,56 @@ func (d *decoder) transitionImplied(el, parent *element) (bool, error) { return false, err } return agree(pSource, subject, "source") - case el.metaclass == mReferenceUsage && owning == mParameterMembership: + case el.metaclass == mReferenceUsage && + (owning == mParameterMembership || owning == mFeatureMembership): direction, stated := d.stringOf(el, rdf.SysML+pDirection) if (direction != "in" && stated) || d.graph.HasProperty(subject, rdf.SysML+pDeclaredName) || d.graph.HasProperty(subject, rdf.SysML+pDeclaredShortName) { return false, nil } if len(d.graph.Objects(subject, rdf.SysML+pOwnedRelationship)) == 0 { - return true, nil + return owning == mParameterMembership, nil } if parent == nil || parent.metaclass != mTransition { return false, nil } - name, ok := d.stringOf(el, rdf.SysML+pName) - if !ok || name != "transitionLinkSource" || len(d.graph.Objects(subject, rdf.SysML+pOwnedAnnotation)) > 0 { + if len(d.graph.Objects(subject, rdf.SysML+pOwnedAnnotation)) > 0 { return false, nil } + hasRedefinition, matchesTransitionSource := false, false for _, relation := range d.graph.Objects(subject, rdf.SysML+pOwnedRelationship) { + relationMeta := d.metaclass(relation) + if relationMeta == mRedefinition { + if !d.graph.BoolValue(relation, rdf.SysML+pIsImplied) { + return false, nil + } + hasRedefinition = true + target := firstIRI(d.graph, relation, "redefinedFeature", pSubsettedFeature, pGeneral, pTarget) + if target.Value != "" { + feature, err := d.referencedElement(target.Value) + if err != nil { + return false, err + } + matchesTransitionSource = matchesTransitionSource || + feature.qname == qualifiedText(libraryTransitionLinkSource) + } + continue + } if !d.graph.BoolValue(relation, rdf.SysML+pIsImplied) && - !impliedRelationshipMetaclasses[d.metaclass(relation)] { + !impliedRelationshipMetaclasses[relationMeta] { return false, nil } } + if hasRedefinition { + return matchesTransitionSource, nil + } + if owning != mParameterMembership { + return false, nil + } + name, ok := d.stringOf(el, rdf.SysML+pName) + if !ok || name != "transitionLinkSource" { + return false, nil + } return d.graph.HasProperty(rdf.IRI(parent.iri), rdf.SysML+pSource) || d.graph.HasProperty(rdf.IRI(parent.iri), rdf.SysML+pSourceFeature), nil case el.metaclass == mAcceptAction && owning == mTransitionFeatureMembership: diff --git a/internal/translate/export/rdf_in_toolkit.go b/internal/translate/export/rdf_in_toolkit.go index cc9edf119b..7cc9261c18 100644 --- a/internal/translate/export/rdf_in_toolkit.go +++ b/internal/translate/export/rdf_in_toolkit.go @@ -255,10 +255,8 @@ func lastSegmentText(qname string) string { return nameText(identityName(segments[len(segments)-1])) } -// deriveNormativeGraph runs the whole normalization over the graph and -// returns the completed graph: a copy first, since the sparse form also -// states defaults this mapping never writes, and a stated default would -// print the keyword a graph carrying none reads the same way. +// deriveNormativeGraph normalizes the owned graph in place, removing stated +// defaults and deriving the collapsed properties this mapping reads. func deriveNormativeGraph(graph *rdf.Graph, metaclasses map[rdf.Term]string) (*rdf.Graph, error) { meta := func(t rdf.Term) string { return rdf.LocalName(metaclasses[t]) } chainIndex := chainOwnerIndex(graph, meta) @@ -708,6 +706,7 @@ func (n *normalizer) deriveSuccessionEnds() { source, target := n.successionEnds(subject) if source.Value != "" { graph.Add(subject, rdf.SysMLTerm(pSourceFeature), source) + graph.Add(subject, rdf.OpenSysMLTerm(xEndVerb), rdf.String("first")) } previous, next := n.sequencedNeighbours(owner, subject) if source.Value == "" && previous.Value != "" && target.Value != "" { @@ -719,13 +718,14 @@ func (n *normalizer) deriveSuccessionEnds() { if source.Value == "" { graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) } - case source.Value == "" && target.Value != "" && target == next: - graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) - graph.Add(subject, rdf.OpenSysMLTerm(xTargetMember), next) - case graph.HasProperty(subject, rdf.SysML+pTargetFeature): + case source.Value != "" && graph.HasProperty(subject, rdf.SysML+pTargetFeature): case next.Value != "": - graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) - graph.Add(subject, rdf.OpenSysMLTerm(xTargetMember), next) + if source.Value == "" { + graph.Add(subject, rdf.OpenSysMLTerm(xEndForm), rdf.String(formThen)) + graph.Add(subject, rdf.OpenSysMLTerm(xTargetMember), next) + } else { + graph.Add(subject, rdf.SysMLTerm(pTargetFeature), next) + } } } } @@ -987,7 +987,7 @@ func (n *normalizer) deriveSatisfySubject(subject rdf.Term) { continue } graph.Add(parameter, rdf.SysMLTerm(pValue), value) - target := firstIRI(graph, value, pReferent, pTargetFeature) + target := firstObject(graph, value, pReferent, pTargetFeature) if target.Value != "" { graph.Add(subject, rdf.SysMLTerm("subject"), target) } @@ -1296,7 +1296,7 @@ func successionEndReferents(graph *rdf.Graph, meta func(rdf.Term) string, succes return out } -// dropStatedDefaults copies the graph without the triples the sparse form +// dropStatedDefaults removes triples the sparse form // writes where this mapping writes nothing: a stated default reads identically // to an absent one, and a printed keyword would declare it twice. func dropStatedDefaults(graph *rdf.Graph, meta func(rdf.Term) string, elementForm bool, chainIndex map[string][]rdf.Term) (*rdf.Graph, error) { @@ -1309,33 +1309,39 @@ func dropStatedDefaults(graph *rdf.Graph, meta func(rdf.Term) string, elementFor if err != nil { return nil, err } - out := rdf.NewGraph() - for _, triple := range graph.Triples() { + var unresolvedTriples []rdf.Triple + graph.RewriteTriples(func(triple *rdf.Triple) bool { if d.dropped(triple.Subject.Value) || d.ownsDroppedMember(triple.Subject) { - continue + return false } object, keep := triple.Object, true if object.IsIRI() { var unresolvedName string - object, unresolvedName, keep = d.iriObject(triple) + object, unresolvedName, keep = d.iriObject(*triple) if keep && unresolvedName != "" { - out.Add(triple.Subject, triple.Predicate, writtenReference(unresolvedName)) - continue + unresolvedTriples = append(unresolvedTriples, rdf.Triple{ + Subject: triple.Subject, Predicate: triple.Predicate, + Object: writtenReference(unresolvedName), + }) + return false } } if keep && !object.IsIRI() { - object, keep = d.literalObject(triple, object) + object, keep = d.literalObject(*triple, object) } if !keep { - continue + return false } triple.Object = object - out.AddTriple(triple) + return true + }) + for _, triple := range unresolvedTriples { + graph.AddTriple(triple) } for member, name := range d.unresolvedRef { - out.Add(rdf.IRI(member), rdf.SysMLTerm(pMemberElement), rdf.String(name)) + graph.Add(rdf.IRI(member), rdf.SysMLTerm(pMemberElement), rdf.String(name)) } - return out, nil + return graph, nil } var ( @@ -1438,6 +1444,16 @@ func (d *defaultDropper) dropped(v string) bool { return d.membershipOwned[v] || d.unresolvedTR[v] } } + if d.implied[v] && d.meta(subject) == mRedefinition { + referencing := firstIRI(d.graph, subject, pOwningRelatedElement, pOwner) + membership := firstIRI(d.graph, referencing, pOwningMembership, pOwningRelationship) + owner := firstIRI(d.graph, membership, pOwningRelatedElement, pOwner) + if d.meta(referencing) == mReferenceUsage && + d.meta(membership) == mParameterMembership && + d.meta(owner) == mTransition { + return d.membershipOwned[v] || d.unresolvedTR[v] + } + } if d.implied[v] && d.meta(subject) == mRedefinition && d.meta(firstIRI(d.graph, subject, pOwningRelatedElement, pOwner)) == mFlowEnd { return d.membershipOwned[v] || d.unresolvedTR[v] diff --git a/internal/translate/export/rdf_normative.go b/internal/translate/export/rdf_normative.go index 6b45cbe5f4..9a6ff60f53 100644 --- a/internal/translate/export/rdf_normative.go +++ b/internal/translate/export/rdf_normative.go @@ -25,6 +25,10 @@ const ( mSubsetting = "Subsetting" mSpecialization = "Specialization" mRedefinition = "Redefinition" + mFlow = "Flow" + mFlowUsage = "FlowUsage" + mSuccessionFlow = "SuccessionFlow" + mSuccessionFlowUsage = "SuccessionFlowUsage" mFlowEnd = "FlowEnd" mPayloadFeature = "PayloadFeature" mMultiplicityRange = "MultiplicityRange" @@ -417,9 +421,40 @@ func (e *encoder) subjectParameter(subject rdf.Term, owner string, target ast.No e.graph.Add(subject, e.sysml(pOwnedRelationship), membership) e.graph.Add(subject, e.sysml(pOwnedMember), usage) e.graph.Add(subject, e.sysml(pOwnedMembership), membership) + if chain, ok := target.(*ast.FeatureChainExpr); ok { + return e.subjectFeatureChainValue(usage, target, chain) + } return e.featureValue(usage, owner, target, false, false) } +func (e *encoder) subjectFeatureChainValue(usage rdf.Term, target ast.Node, chainExpr *ast.FeatureChainExpr) error { + expression := e.ids.mintedNode(rdf.ExpressionIRI(usage, "value"), usage, "value") + e.graph.Add(usage, e.sysml(pValue), expression) + e.graph.Add(expression, e.sysx(xSourceText), rdf.String(e.text(target))) + e.graph.Add(expression, e.sysml(pElementID), rdf.String(rdf.LocalName(expression.Value))) + e.typed(expression, mFeatureReference) + + chain := e.ids.mintedNode(rdf.ExpressionIRI(expression, "referent"), expression, "referent") + e.typed(chain, mFeature) + e.graph.Add(chain, e.sysml(pElementID), rdf.String(rdf.LocalName(chain.Value))) + var links []rdf.Term + for _, segment := range featureChainSegments(chainExpr) { + if qualifiedNameHasChain(segment) { + links = append(links, e.qualifiedChainReferences(segment)...) + } else { + links = append(links, e.reference(segment)) + } + } + e.featureChainings(chain, links) + membership := e.ids.minted(rdf.OwningMembershipIRIOf(chain), chain, rdf.OwningMembershipSuffix) + e.emitMembershipCore(membership, chain, expression, mOwningMembership, true) + e.graph.Add(expression, e.sysml(pOwnedRelationship), membership) + e.graph.Add(expression, e.sysml(pOwnedMembership), membership) + e.graph.Add(expression, e.sysml(pReferent), chain) + e.resultParameter(expression) + return e.expressionOwnership(expression, usage, mFeatureValue) +} + // subjectParameters emits a subject parameter per `by` target the head states // (SysML.xtext SatisfyRequirementUsage `subject`); the collapsed `subject` // property the relationships pass wrote stays beside it. diff --git a/internal/translate/export/rdf_normative_test.go b/internal/translate/export/rdf_normative_test.go index 94c0211986..20f3114b38 100644 --- a/internal/translate/export/rdf_normative_test.go +++ b/internal/translate/export/rdf_normative_test.go @@ -124,6 +124,63 @@ func TestSuccessionEndsUseExternalMembershipSource(t *testing.T) { } } +func TestSuccessionEndsFromNamedMembersUseExplicitFirst(t *testing.T) { + graph := rdf.NewGraph() + owner := elmt("owner") + source := elmt("source") + succession := elmt("succession") + target := elmt("target") + sourceEnd := elmt("succession__source") + sourceMembership := elmt("succession__source-membership") + targetEnd := elmt("succession__target") + targetMembership := elmt("succession__target-membership") + for subject, metaclass := range map[rdf.Term]string{ + source: "OccurrenceUsage", + succession: mSuccession, + target: "OccurrenceUsage", + sourceEnd: mReferenceUsage, + sourceMembership: mEndFeatureMembership, + targetEnd: mReferenceUsage, + targetMembership: mEndFeatureMembership, + } { + graph.Add(subject, rdf.IRI(rdf.RDFType), rdf.SysMLTerm(metaclass)) + } + for _, end := range []struct { + membership rdf.Term + element rdf.Term + }{ + {sourceMembership, sourceEnd}, + {targetMembership, targetEnd}, + } { + graph.Add(succession, rdf.SysMLTerm(pOwnedRelationship), end.membership) + graph.Add(end.membership, rdf.SysMLTerm(pMemberElement), end.element) + } + graph.Add(sourceEnd, rdf.SysMLTerm(pReferences), source) + graph.Add(targetEnd, rdf.SysMLTerm(pReferences), target) + + n := &normalizer{ + graph: graph, + meta: func(term rdf.Term) string { + return rdf.LocalName(graph.Type(term)) + }, + memberOwner: map[string]rdf.Term{succession.Value: owner}, + ownerMembers: map[string][]rdf.Term{ + owner.Value: {source, succession, target}, + }, + } + n.deriveSuccessionEnds() + + if got, ok := graph.Object(succession, rdf.OpenSysML+xEndVerb); !ok || got != rdf.String("first") { + t.Fatalf("succession end verb %v, want first", got) + } + if got, ok := graph.Object(succession, rdf.SysML+pTargetFeature); !ok || got != target { + t.Fatalf("succession target %v, want %s", got, target) + } + if graph.HasProperty(succession, rdf.OpenSysML+xEndForm) { + t.Fatal("a named succession source should not use positional then form") + } +} + func TestSequencesFromMatchesInitialMembershipReferent(t *testing.T) { graph := rdf.NewGraph() membership := elmt("initial-membership") diff --git a/internal/translate/export/root_namespace.go b/internal/translate/export/root_namespace.go index 3c48e14ad5..a91287201a 100644 --- a/internal/translate/export/root_namespace.go +++ b/internal/translate/export/root_namespace.go @@ -139,22 +139,15 @@ func withoutRootNamespace(graph *rdf.Graph) *rdf.Graph { if len(dropped) == 0 { return graph } - out := rdf.NewGraph() - for prefix, iri := range graph.Prefixes { - out.Prefixes[prefix] = iri - } - for _, triple := range graph.Triples() { - if dropped[triple.Subject.Value] || - dropped[triple.Object.Value] && triple.Object.IsIRI() || - droppedMemberIndexes[triple.Subject.Value] && triple.Predicate.Value == rdf.OpenSysML+xMemberIndex { - continue - } - out.AddTriple(triple) - } + graph.RewriteTriples(func(triple *rdf.Triple) bool { + return !dropped[triple.Subject.Value] && + !(dropped[triple.Object.Value] && triple.Object.IsIRI()) && + !(droppedMemberIndexes[triple.Subject.Value] && triple.Predicate.Value == rdf.OpenSysML+xMemberIndex) + }) for _, index := range indexes { - out.Add(index.member, rdf.OpenSysMLTerm(xMemberIndex), rdf.Int(index.index)) + graph.Add(index.member, rdf.OpenSysMLTerm(xMemberIndex), rdf.Int(index.index)) } - return out + return graph } type rootIndex struct { diff --git a/internal/translate/rdf/graph_fastpath_test.go b/internal/translate/rdf/graph_fastpath_test.go index fa3e2f3cad..500a3a2afc 100644 --- a/internal/translate/rdf/graph_fastpath_test.go +++ b/internal/translate/rdf/graph_fastpath_test.go @@ -30,6 +30,165 @@ func TestNewGraphOfDropsDuplicatesOnceAddedTo(t *testing.T) { } } +func TestGraphBuilderPreservesOrderAndDropsDuplicates(t *testing.T) { + p := IRI(Element + "P") + first := Triple{Subject: p, Predicate: SysMLTerm("declaredName"), Object: String("P")} + second := Triple{Subject: p, Predicate: SysMLTerm("ownedMember"), Object: IRI(Element + "P__A")} + builder := NewGraphBuilder(3) + builder.AddTriple(first) + builder.AddTriple(second) + builder.AddTriple(first) + + graph := builder.Build() + if !slices.Equal(graph.Triples(), []Triple{first, second}) { + t.Fatalf("built triples = %v, want %v", graph.Triples(), []Triple{first, second}) + } + if graph.Prefixes["sysml"] != SysML || !graph.Has(first) { + t.Fatalf("built graph prefixes or membership are incorrect: %v", graph.Prefixes) + } + builder.Add(IRI(Element+"Q"), SysMLTerm("declaredName"), String("Q")) + if !slices.Equal(graph.Triples(), []Triple{first, second}) { + t.Fatalf("adding to a used builder changed its graph: %v", graph.Triples()) + } +} + +func TestHasBuildsIndexWhenNoCacheExists(t *testing.T) { + triple := Triple{Subject: IRI(Element + "P"), Predicate: SysMLTerm("declaredName"), Object: String("P")} + graph := NewGraphOf([]Triple{triple}, nil) + if graph.index != nil || !graph.Has(triple) || graph.index == nil { + t.Fatalf("Has did not build and use the subject index: index=%v", graph.index) + } +} + +func TestCompactKeepsGraphQueriesAndDropsDuplicateSet(t *testing.T) { + p := IRI(Element + "P") + t1 := Triple{Subject: p, Predicate: SysMLTerm("declaredName"), Object: String("P")} + t2 := Triple{Subject: p, Predicate: SysMLTerm("ownedMember"), Object: IRI(Element + "P__A")} + g := NewGraphOf([]Triple{t1, t2}, map[string]string{"sysml": SysML}) + if got := g.Objects(p, SysML+"ownedMember"); !slices.Equal(got, []Term{t2.Object}) { + t.Fatalf("ownedMember before compact = %v", got) + } + g.Compact() + if !g.Has(t1) || g.Has(Triple{Subject: p, Predicate: SysMLTerm("ownedMember"), Object: IRI(Element + "P__B")}) { + t.Fatal("Has changed after compact") + } + g.AddTriple(t2) + if !slices.Equal(g.Triples(), []Triple{t1, t2}) { + t.Fatalf("adding a held triple after compact changed the graph: %v", g.Triples()) + } +} + +func TestCompactReleasesExcessTripleCapacity(t *testing.T) { + builder := NewGraphBuilder(10) + builder.Add(IRI(Element+"A"), SysMLTerm("declaredName"), String("A")) + builder.Add(IRI(Element+"B"), SysMLTerm("declaredName"), String("B")) + graph := builder.Build() + if cap(graph.triples) <= len(graph.triples)+len(graph.triples)/2 { + t.Fatalf("test graph capacity %d is not excessive for %d triples", cap(graph.triples), len(graph.triples)) + } + + graph.Compact() + if cap(graph.triples) != len(graph.triples) { + t.Fatalf("compacted capacity = %d, want %d", cap(graph.triples), len(graph.triples)) + } +} + +func TestRewriteTriplesRebuildsGraphIndexesAndDuplicateSet(t *testing.T) { + a, b := IRI(Element+"A"), IRI(Element+"B") + predicate := SysMLTerm("declaredName") + first := Triple{Subject: a, Predicate: predicate, Object: String("A")} + second := Triple{Subject: a, Predicate: predicate, Object: String("B")} + removed := Triple{Subject: b, Predicate: predicate, Object: String("B")} + g := NewGraph() + g.AddTriple(first) + g.AddTriple(second) + g.AddTriple(removed) + g.Subjects() + g.Objects(a, predicate.Value) + + g.RewriteTriples(func(triple *Triple) bool { + if got := g.Objects(a, predicate.Value); !slices.Equal(got, []Term{first.Object, second.Object}) { + t.Errorf("lookup during rewrite = %v, want the original objects", got) + } + if triple.Subject == b { + return false + } + triple.Object = first.Object + return true + }) + if got := g.Triples(); !slices.Equal(got, []Triple{first}) { + t.Fatalf("rewritten triples = %v, want the duplicate-free first triple", got) + } + if got := g.Subjects(); !slices.Equal(got, []Term{a}) { + t.Fatalf("rewritten subjects = %v, want only %v", got, a) + } + g.AddTriple(first) + g.AddTriple(second) + if got := g.Triples(); !slices.Equal(got, []Triple{first, second}) { + t.Fatalf("adding after rewrite = %v, want the original and a new triple", got) + } +} + +func TestRewriteTriplesDoesNotBuildDuplicateSetForUnchangedUniqueTriples(t *testing.T) { + a, b := IRI(Element+"A"), IRI(Element+"B") + graph := NewGraphOf([]Triple{ + {Subject: a, Predicate: SysMLTerm("declaredName"), Object: String("A")}, + {Subject: b, Predicate: SysMLTerm("declaredName"), Object: String("B")}, + }, nil) + graph.Subjects() + + graph.RewriteTriples(func(triple *Triple) bool { + return triple.Subject == a + }) + if graph.seen != nil { + t.Fatal("rewrite built a duplicate set for unchanged unique triples") + } + if got := graph.Triples(); !slices.Equal(got, []Triple{ + {Subject: a, Predicate: SysMLTerm("declaredName"), Object: String("A")}, + }) { + t.Fatalf("rewritten triples = %v, want only subject %v", got, a) + } +} + +func TestSubjectsCachesInsertionOrderAcrossGraphGrowth(t *testing.T) { + a, b := IRI(Element+"A"), IRI(Element+"B") + g := NewGraphOf([]Triple{ + {Subject: a, Predicate: SysMLTerm("declaredName"), Object: String("A")}, + {Subject: b, Predicate: SysMLTerm("declaredName"), Object: String("B")}, + }, nil) + got := g.Subjects() + got[0] = b + g.Add(a, SysMLTerm("qualifiedName"), String("A")) + g.Add(IRI(Element+"C"), SysMLTerm("declaredName"), String("C")) + if want := []Term{a, b, IRI(Element + "C")}; !slices.Equal(g.Subjects(), want) { + t.Fatalf("Subjects after mutation = %v, want %v", g.Subjects(), want) + } +} + +func TestSubjectsDeduplicatesBySubjectValue(t *testing.T) { + iri := IRI(Element + "same") + literal := String(iri.Value) + other := IRI(Element + "other") + graph := NewGraphOf([]Triple{ + {Subject: iri, Predicate: SysMLTerm("declaredName"), Object: String("same")}, + }, nil) + graph.Subjects() + graph.Add(literal, SysMLTerm("declaredName"), String("literal subject")) + graph.Add(other, SysMLTerm("declaredName"), String("other")) + if got, want := graph.Subjects(), []Term{iri, other}; !slices.Equal(got, want) { + t.Fatalf("Subjects = %v, want %v", got, want) + } + graph.RewriteTriples(func(triple *Triple) bool { + if triple.Subject == other { + triple.Subject = String(iri.Value) + } + return true + }) + if got, want := graph.Subjects(), []Term{iri}; !slices.Equal(got, want) { + t.Fatalf("Subjects after rewrite = %v, want %v", got, want) + } +} + // A graph whose typed triples already state each annotated collection in // annotation order is returned as it is; one whose annotation orders them // differently is rewritten in annotation order, leaving the input alone. diff --git a/internal/translate/rdf/term.go b/internal/translate/rdf/term.go index 5c99fd8612..ba67fd9016 100644 --- a/internal/translate/rdf/term.go +++ b/internal/translate/rdf/term.go @@ -11,6 +11,7 @@ package rdf import ( "fmt" + "hash/maphash" "strings" ) @@ -105,24 +106,119 @@ type Graph struct { // index groups statements by subject. It is built on the first lookup and // kept current as triples are added. index map[Term]*subjectIndex + // subjectOrder caches distinct subjects in insertion order once requested. + subjectOrder []Term + subjectSet map[string]struct{} + subjectsReady bool +} + +// GraphBuilder collects triples without building the graph's lookup indexes. +type GraphBuilder struct { + triples []Triple + prefixes map[string]string } // subjectIndex holds one subject's statements, keeping predicates in insertion // order so serialization stays stable. type subjectIndex struct { predicates []string - objects map[string][]Term + objects map[string][]int } // NewGraph returns an empty graph carrying the SysML prefix bindings. func NewGraph() *Graph { - g := &Graph{seen: make(map[Triple]bool), Prefixes: make(map[string]string)} + return NewGraphWithCapacity(0) +} + +// NewGraphWithCapacity returns an empty graph with space for capacity triples. +func NewGraphWithCapacity(capacity int) *Graph { + g := &Graph{ + triples: make([]Triple, 0, capacity), + seen: make(map[Triple]bool, capacity), + Prefixes: make(map[string]string), + } for prefix, ns := range DefaultPrefixes { g.Prefixes[prefix] = ns } return g } +// NewGraphBuilder returns a bulk graph builder with space for capacity triples. +func NewGraphBuilder(capacity int) *GraphBuilder { + prefixes := make(map[string]string, len(DefaultPrefixes)) + for prefix, ns := range DefaultPrefixes { + prefixes[prefix] = ns + } + return &GraphBuilder{triples: make([]Triple, 0, capacity), prefixes: prefixes} +} + +// SetPrefix sets a namespace binding on the graph being built. +func (b *GraphBuilder) SetPrefix(prefix, namespace string) { + b.prefixes[prefix] = namespace +} + +// Add appends a triple to the builder. +func (b *GraphBuilder) Add(subject, predicate, object Term) { + b.AddTriple(Triple{Subject: subject, Predicate: predicate, Object: object}) +} + +// AddTriple appends a triple to the builder. +func (b *GraphBuilder) AddTriple(triple Triple) { + b.triples = append(b.triples, triple) +} + +// Build returns a graph with duplicate triples removed in insertion order. +func (b *GraphBuilder) Build() *Graph { + seed := maphash.MakeSeed() + seen := make(map[uint64]int, len(b.triples)) + var collisions map[uint64][]int + triples := b.triples[:0] + for _, triple := range b.triples { + hash := tripleHash(triple, seed) + if first, exists := seen[hash]; exists { + duplicate := triples[first] == triple + if !duplicate { + for _, index := range collisions[hash] { + if triples[index] == triple { + duplicate = true + break + } + } + } + if duplicate { + continue + } + if collisions == nil { + collisions = make(map[uint64][]int) + } + collisions[hash] = append(collisions[hash], len(triples)) + } else { + seen[hash] = len(triples) + } + triples = append(triples, triple) + } + b.triples = nil + return NewGraphOf(triples, b.prefixes) +} + +func tripleHash(triple Triple, seed maphash.Seed) uint64 { + var hash maphash.Hash + hash.SetSeed(seed) + write := func(term Term) { + _ = hash.WriteByte(byte(term.Kind)) + _, _ = hash.WriteString(term.Value) + _ = hash.WriteByte(0) + _, _ = hash.WriteString(term.Datatype) + _ = hash.WriteByte(0) + _, _ = hash.WriteString(term.Lang) + _ = hash.WriteByte(0xff) + } + write(triple.Subject) + write(triple.Predicate) + write(triple.Object) + return hash.Sum64() +} + // NewGraphOf returns a graph holding triples, in order, with prefixes. The // triples must be distinct: the set that drops duplicates is built only when a // triple is added or looked up, so a graph assembled from a known-distinct list @@ -153,27 +249,48 @@ func (g *Graph) Add(subject, predicate, object Term) { // AddTriple appends t unless the graph already contains it. func (g *Graph) AddTriple(t Triple) { - seen := g.set() - if seen[t] { - return + if g.seen != nil { + if g.seen[t] { + return + } + g.seen[t] = true + } else if g.index != nil { + if si := g.index[t.Subject]; si != nil { + for _, index := range si.objects[t.Predicate.Value] { + if g.triples[index].Object == t.Object { + return + } + } + } + } else { + seen := g.set() + if seen[t] { + return + } + seen[t] = true } - seen[t] = true g.triples = append(g.triples, t) + if g.subjectsReady { + if _, exists := g.subjectSet[t.Subject.Value]; !exists { + g.subjectSet[t.Subject.Value] = struct{}{} + g.subjectOrder = append(g.subjectOrder, t.Subject) + } + } if g.index != nil { - g.index[t.Subject] = indexTriple(g.index[t.Subject], t) + g.index[t.Subject] = indexTriple(g.index[t.Subject], t, len(g.triples)-1) } } // indexTriple records t under its subject's index entry, creating the entry // when si is nil. -func indexTriple(si *subjectIndex, t Triple) *subjectIndex { +func indexTriple(si *subjectIndex, t Triple, index int) *subjectIndex { if si == nil { - si = &subjectIndex{objects: make(map[string][]Term)} + si = &subjectIndex{objects: make(map[string][]int)} } - if _, seen := si.objects[t.Predicate.Value]; !seen { + if len(si.objects[t.Predicate.Value]) == 0 { si.predicates = append(si.predicates, t.Predicate.Value) } - si.objects[t.Predicate.Value] = append(si.objects[t.Predicate.Value], t.Object) + si.objects[t.Predicate.Value] = append(si.objects[t.Predicate.Value], index) return si } @@ -185,8 +302,8 @@ func (g *Graph) subjects() map[Term]*subjectIndex { return g.index } g.index = make(map[Term]*subjectIndex) - for _, t := range g.triples { - g.index[t.Subject] = indexTriple(g.index[t.Subject], t) + for i, t := range g.triples { + g.index[t.Subject] = indexTriple(g.index[t.Subject], t, i) } return g.index } @@ -196,22 +313,158 @@ func (g *Graph) subjects() map[Term]*subjectIndex { func (g *Graph) Triples() []Triple { return g.triples } // Has reports whether the graph contains t. -func (g *Graph) Has(t Triple) bool { return g.set()[t] } +func (g *Graph) Has(t Triple) bool { + if g.seen != nil { + return g.seen[t] + } + if g.index != nil { + si := g.index[t.Subject] + if si == nil { + return false + } + for _, index := range si.objects[t.Predicate.Value] { + if g.triples[index].Object == t.Object { + return true + } + } + return false + } + si := g.subjects()[t.Subject] + if si == nil { + return false + } + for _, index := range si.objects[t.Predicate.Value] { + if g.triples[index].Object == t.Object { + return true + } + } + return false +} + +// Compact releases duplicate detection and excess triple storage. +func (g *Graph) Compact() { + g.seen = nil + if cap(g.triples)-len(g.triples) > len(g.triples)/2 { + g.triples = append([]Triple(nil), g.triples...) + } +} + +// RewriteTriples rewrites the graph in order, removing triples the callback +// declines. Graph lookups during the rewrite see the original statements. +func (g *Graph) RewriteTriples(rewrite func(*Triple) bool) { + if g.index == nil { + g.subjects() + } + triples := g.triples + keep := make([]bool, len(triples)) + type update struct { + index int + triple Triple + } + var updates []update + removed := false + changed := false + for i := range triples { + triple := triples[i] + if !rewrite(&triple) { + removed = true + continue + } + keep[i] = true + if triple != triples[i] { + changed = true + updates = append(updates, update{index: i, triple: triple}) + } + } + if !removed && !changed { + return + } + retained := triples[:0] + nextUpdate := 0 + for i, triple := range triples { + if !keep[i] { + continue + } + if nextUpdate < len(updates) && updates[nextUpdate].index == i { + triple = updates[nextUpdate].triple + nextUpdate++ + } + retained = append(retained, triple) + } + seen := g.seen + if seen != nil { + clear(seen) + } + unique := retained + if seen != nil || changed { + if seen == nil { + seen = make(map[Triple]bool, len(retained)) + } + unique = retained[:0] + for _, triple := range retained { + if seen[triple] { + continue + } + seen[triple] = true + unique = append(unique, triple) + } + } + g.triples = unique + g.seen = nil + for _, index := range g.index { + for predicate, objects := range index.objects { + index.objects[predicate] = objects[:0] + } + index.predicates = index.predicates[:0] + } + for i, triple := range unique { + g.index[triple.Subject] = indexTriple(g.index[triple.Subject], triple, i) + } + for subject, index := range g.index { + for predicate, objects := range index.objects { + if len(objects) == 0 { + delete(index.objects, predicate) + } + } + if len(index.predicates) == 0 { + delete(g.index, subject) + } + } + g.subjectOrder = g.subjectOrder[:0] + if g.subjectSet == nil { + g.subjectSet = make(map[string]struct{}, len(unique)) + } else { + clear(g.subjectSet) + } + for _, triple := range unique { + if _, exists := g.subjectSet[triple.Subject.Value]; exists { + continue + } + g.subjectSet[triple.Subject.Value] = struct{}{} + g.subjectOrder = append(g.subjectOrder, triple.Subject) + } + g.subjectsReady = true +} // Len returns the number of triples. func (g *Graph) Len() int { return len(g.triples) } // Subjects returns every distinct subject IRI in insertion order. func (g *Graph) Subjects() []Term { - var out []Term - seen := make(map[string]bool) - for _, t := range g.triples { - if seen[t.Subject.Value] { - continue + if !g.subjectsReady { + g.subjectOrder = make([]Term, 0) + g.subjectSet = make(map[string]struct{}) + for _, t := range g.triples { + if _, exists := g.subjectSet[t.Subject.Value]; exists { + continue + } + g.subjectSet[t.Subject.Value] = struct{}{} + g.subjectOrder = append(g.subjectOrder, t.Subject) } - seen[t.Subject.Value] = true - out = append(out, t.Subject) + g.subjectsReady = true } + out := make([]Term, len(g.subjectOrder)) + copy(out, g.subjectOrder) return out } @@ -239,7 +492,9 @@ func (g *Graph) Objects(subject Term, predicate string) []Term { } // Copied so a caller appending to the result cannot reach into the index. out := make([]Term, len(found)) - copy(out, found) + for i, index := range found { + out[i] = g.triples[index].Object + } return out } @@ -251,7 +506,7 @@ func (g *Graph) Object(subject Term, predicate string) (Term, bool) { return Term{}, false } if found := si.objects[predicate]; len(found) > 0 { - return found[0], true + return g.triples[found[0]].Object, true } return Term{}, false } diff --git a/internal/translate/rdf/turtle_write.go b/internal/translate/rdf/turtle_write.go index 580689a716..3f4fad3c75 100644 --- a/internal/translate/rdf/turtle_write.go +++ b/internal/translate/rdf/turtle_write.go @@ -50,8 +50,8 @@ func writeSubject(b *strings.Builder, g *Graph, subject Term) { }) for i, predicate := range predicates { objects := make([]string, 0, len(byPredicate[predicate])) - for _, object := range byPredicate[predicate] { - objects = append(objects, g.term(object)) + for _, index := range byPredicate[predicate] { + objects = append(objects, g.term(g.triples[index].Object)) } name := g.term(IRI(predicate)) if predicate == RDFType { diff --git a/tests/export/testdata/interchange/README.md b/tests/export/testdata/interchange/README.md index 3a34a0ad4a..c22562d6d7 100644 --- a/tests/export/testdata/interchange/README.md +++ b/tests/export/testdata/interchange/README.md @@ -1 +1,3 @@ The two library identity JSON fixtures are toolkit v0.10.0 full-JSON exports with a hand-edited `ScalarValues::Real` library stub id; the unmatched case also changes its qualified name. + +The `satisfy_by` fixture is a toolkit v0.10.0 full-JSON export of the adjacent source model. diff --git a/tests/export/testdata/interchange/satisfy_by.sysml b/tests/export/testdata/interchange/satisfy_by.sysml new file mode 100644 index 0000000000..db33c4bdfb --- /dev/null +++ b/tests/export/testdata/interchange/satisfy_by.sysml @@ -0,0 +1,11 @@ +package SatisfyCases { + part def Vehicle { + part engine : Engine; + } + part def Engine; + part vehicle : Vehicle; + requirement def MissionRequirement; + requirement mission : MissionRequirement { + satisfy mission by vehicle.engine; + } +} diff --git a/tests/export/testdata/interchange/satisfy_by.toolkit.full.json b/tests/export/testdata/interchange/satisfy_by.toolkit.full.json new file mode 100644 index 0000000000..d4625d84db --- /dev/null +++ b/tests/export/testdata/interchange/satisfy_by.toolkit.full.json @@ -0,0 +1,3627 @@ +[ + { + "@id": "01681e9f-cb49-5954-b950-df259366756e", + "@type": "Namespace", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "01681e9f-cb49-5954-b950-df259366756e", + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "membership": [ + { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4" + } + ], + "name": null, + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "ownedMembership": [ + { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4" + } + ], + "ownedRelationship": [ + { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4" + } + ], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelationship": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2f3b358f-db56-5b93-87e7-718462eb4bc4", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "memberElementId": "d34f71f6-516c-5046-897d-4ee0a36ad111", + "memberName": "SatisfyCases", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "ownedMemberElementId": "d34f71f6-516c-5046-897d-4ee0a36ad111", + "ownedMemberName": "SatisfyCases", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + }, + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "shortName": null, + "source": [ + { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + } + ], + "target": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111", + "@type": "Package", + "aliasIds": [], + "declaredName": "SatisfyCases", + "declaredShortName": null, + "documentation": [], + "elementId": "d34f71f6-516c-5046-897d-4ee0a36ad111", + "filterCondition": [], + "importedMembership": [], + "isImpliedIncluded": true, + "isLibraryElement": false, + "member": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "membership": [ + { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e" + }, + { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98" + }, + { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5" + }, + { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834" + }, + { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094" + } + ], + "name": "SatisfyCases", + "ownedAnnotation": [], + "ownedElement": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "ownedImport": [], + "ownedMember": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "ownedMembership": [ + { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e" + }, + { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98" + }, + { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5" + }, + { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834" + }, + { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094" + } + ], + "ownedRelationship": [ + { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e" + }, + { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98" + }, + { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5" + }, + { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834" + }, + { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094" + } + ], + "owner": { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + }, + "owningMembership": { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4" + }, + "owningNamespace": { + "@id": "01681e9f-cb49-5954-b950-df259366756e" + }, + "owningRelationship": { + "@id": "2f3b358f-db56-5b93-87e7-718462eb4bc4" + }, + "qualifiedName": "SatisfyCases", + "shortName": null, + "textualRepresentation": [] + }, + { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "memberElementId": "f7e7d98d-2960-5f44-88a5-f76924c19597", + "memberName": "Vehicle", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "ownedMemberElementId": "f7e7d98d-2960-5f44-88a5-f76924c19597", + "ownedMemberName": "Vehicle", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "shortName": null, + "source": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "target": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Vehicle", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "f7e7d98d-2960-5f44-88a5-f76924c19597", + "endFeature": [], + "feature": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "featureMembership": [ + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + } + ], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "membership": [ + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + } + ], + "multiplicity": null, + "name": "Vehicle", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedFeatureMembership": [ + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + } + ], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedMember": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedMembership": [ + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + } + ], + "ownedMetadata": [], + "ownedOccurrence": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedPart": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + }, + { + "@id": "4ca9c4a5-5981-5ede-9c5d-fcdc1c787d7a" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "4ca9c4a5-5981-5ede-9c5d-fcdc1c787d7a" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "4ca9c4a5-5981-5ede-9c5d-fcdc1c787d7a" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningMembership": { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e" + }, + "owningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": { + "@id": "fe67ec45-eb13-58fa-8dee-14ba6d6e7e9e" + }, + "qualifiedName": "SatisfyCases::Vehicle", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "07133f0e-55e4-53af-829f-5a6a51287492", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "memberElementId": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde", + "memberName": "engine", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "ownedMemberElementId": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde", + "ownedMemberFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "ownedMemberName": "engine", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningRelationship": null, + "owningType": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "shortName": null, + "source": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "target": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "engine", + "declaredShortName": null, + "definition": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "engine", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "790a0c64-ccd4-5227-b6ca-54ea64a4d0d4" + }, + { + "@id": "8b09ec52-e5fe-5160-913f-334be332898c" + } + ], + "ownedSpecialization": [ + { + "@id": "790a0c64-ccd4-5227-b6ca-54ea64a4d0d4" + }, + { + "@id": "8b09ec52-e5fe-5160-913f-334be332898c" + } + ], + "ownedSubsetting": [ + { + "@id": "8b09ec52-e5fe-5160-913f-334be332898c" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "790a0c64-ccd4-5227-b6ca-54ea64a4d0d4" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningDefinition": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningFeatureMembership": { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + }, + "owningMembership": { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + }, + "owningNamespace": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningRelationship": { + "@id": "07133f0e-55e4-53af-829f-5a6a51287492" + }, + "owningType": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningUsage": null, + "partDefinition": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "portionKind": null, + "qualifiedName": "SatisfyCases::Vehicle::engine", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "790a0c64-ccd4-5227-b6ca-54ea64a4d0d4", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "790a0c64-ccd4-5227-b6ca-54ea64a4d0d4", + "general": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "owningRelationship": null, + "owningType": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "shortName": null, + "source": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "specific": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "target": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "textualRepresentation": [], + "type": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "typedFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + }, + { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "0679b410-ec86-5594-9ccf-7144023b9d98", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "memberElementId": "2d014161-d2a0-590a-9330-3f63dacbab49", + "memberName": "Engine", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "ownedMemberElementId": "2d014161-d2a0-590a-9330-3f63dacbab49", + "ownedMemberName": "Engine", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "shortName": null, + "source": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "target": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49", + "@type": "PartDefinition", + "aliasIds": [], + "declaredName": "Engine", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "2d014161-d2a0-590a-9330-3f63dacbab49", + "endFeature": [], + "feature": [], + "featureMembership": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "Engine", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "6d09e68c-8e5d-5618-b54c-a90f054d6e23" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "6d09e68c-8e5d-5618-b54c-a90f054d6e23" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "6d09e68c-8e5d-5618-b54c-a90f054d6e23" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningMembership": { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98" + }, + "owningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": { + "@id": "0679b410-ec86-5594-9ccf-7144023b9d98" + }, + "qualifiedName": "SatisfyCases::Engine", + "shortName": null, + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3550f483-261d-5438-bca4-4ef2213f77b5", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "memberElementId": "19b04e5e-f144-5c01-8bc4-43338c0c9c65", + "memberName": "vehicle", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "ownedMemberElementId": "19b04e5e-f144-5c01-8bc4-43338c0c9c65", + "ownedMemberName": "vehicle", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "shortName": null, + "source": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "target": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65", + "@type": "PartUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": "vehicle", + "declaredShortName": null, + "definition": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "19b04e5e-f144-5c01-8bc4-43338c0c9c65", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "featuringType": [], + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "itemDefinition": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "mayTimeVary": null, + "member": [], + "membership": [], + "multiplicity": null, + "name": "vehicle", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "e0942b10-c053-585f-890c-9044f752dfc9" + }, + { + "@id": "ef4923e3-ec13-5a8b-adfb-d719cc3c9af8" + } + ], + "ownedSpecialization": [ + { + "@id": "e0942b10-c053-585f-890c-9044f752dfc9" + }, + { + "@id": "ef4923e3-ec13-5a8b-adfb-d719cc3c9af8" + } + ], + "ownedSubsetting": [ + { + "@id": "ef4923e3-ec13-5a8b-adfb-d719cc3c9af8" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "e0942b10-c053-585f-890c-9044f752dfc9" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5" + }, + "owningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": { + "@id": "3550f483-261d-5438-bca4-4ef2213f77b5" + }, + "owningType": null, + "owningUsage": null, + "partDefinition": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "portionKind": null, + "qualifiedName": "SatisfyCases::vehicle", + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "e0942b10-c053-585f-890c-9044f752dfc9", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "e0942b10-c053-585f-890c-9044f752dfc9", + "general": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "owningRelationship": null, + "owningType": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "shortName": null, + "source": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "specific": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "target": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "textualRepresentation": [], + "type": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "typedFeature": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + }, + { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "54171709-55b0-5ac0-a0a5-159572e00834", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "memberElementId": "9591768d-756a-55a2-a746-66a99cebffad", + "memberName": "MissionRequirement", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "ownedMemberElementId": "9591768d-756a-55a2-a746-66a99cebffad", + "ownedMemberName": "MissionRequirement", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "shortName": null, + "source": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "target": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad", + "@type": "RequirementDefinition", + "actorParameter": [], + "aliasIds": [], + "assumedConstraint": [], + "declaredName": "MissionRequirement", + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "documentation": [], + "elementId": "9591768d-756a-55a2-a746-66a99cebffad", + "endFeature": [], + "expression": [], + "feature": [], + "featureMembership": [], + "framedConcern": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isConjugated": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isSufficient": false, + "isVariation": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": "MissionRequirement", + "output": [], + "ownedAction": [], + "ownedAllocation": [], + "ownedAnalysisCase": [], + "ownedAnnotation": [], + "ownedAttribute": [], + "ownedCalculation": [], + "ownedCase": [], + "ownedConcern": [], + "ownedConjugator": null, + "ownedConnection": [], + "ownedConstraint": [], + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedEnumeration": [], + "ownedFeature": [], + "ownedFeatureMembership": [], + "ownedFlow": [], + "ownedImport": [], + "ownedInterface": [], + "ownedIntersecting": [], + "ownedItem": [], + "ownedMember": [], + "ownedMembership": [], + "ownedMetadata": [], + "ownedOccurrence": [], + "ownedPart": [], + "ownedPort": [], + "ownedReference": [], + "ownedRelationship": [ + { + "@id": "43bca579-d715-521b-a6bf-b55b626f0e69" + } + ], + "ownedRendering": [], + "ownedRequirement": [], + "ownedSpecialization": [ + { + "@id": "43bca579-d715-521b-a6bf-b55b626f0e69" + } + ], + "ownedState": [], + "ownedSubclassification": [ + { + "@id": "43bca579-d715-521b-a6bf-b55b626f0e69" + } + ], + "ownedTransition": [], + "ownedUnioning": [], + "ownedUsage": [], + "ownedUseCase": [], + "ownedVerificationCase": [], + "ownedView": [], + "ownedViewpoint": [], + "owner": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningMembership": { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834" + }, + "owningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": { + "@id": "54171709-55b0-5ac0-a0a5-159572e00834" + }, + "parameter": [], + "qualifiedName": "SatisfyCases::MissionRequirement", + "reqId": null, + "requiredConstraint": [], + "result": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "shortName": null, + "stakeholderParameter": [], + "step": [], + "subjectParameter": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "text": [], + "textualRepresentation": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "3675ed7f-88a5-5418-8afb-14956897c094", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "memberElementId": "ddf58eb2-e917-525b-80bf-be2b5da6dec8", + "memberName": "mission", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "ownedMemberElementId": "ddf58eb2-e917-525b-80bf-be2b5da6dec8", + "ownedMemberName": "mission", + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "shortName": null, + "source": [ + { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + } + ], + "target": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8", + "@type": "RequirementUsage", + "actorParameter": [], + "aliasIds": [], + "assumedConstraint": [], + "behavior": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "chainingFeature": [], + "constraintDefinition": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "crossFeature": null, + "declaredName": "mission", + "declaredShortName": null, + "definition": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "ddf58eb2-e917-525b-80bf-be2b5da6dec8", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "featureMembership": [ + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + } + ], + "featureTarget": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "featuringType": [], + "framedConcern": [], + "function": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isOrdered": false, + "isPortion": false, + "isReference": true, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "membership": [ + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + } + ], + "multiplicity": null, + "name": "mission", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "ownedMembership": [ + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "86bfb0af-1b47-550c-9439-458329c0a722" + }, + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + }, + { + "@id": "a505bff6-1b93-5a91-a49a-a881cd8d74f8" + } + ], + "ownedSpecialization": [ + { + "@id": "86bfb0af-1b47-550c-9439-458329c0a722" + }, + { + "@id": "a505bff6-1b93-5a91-a49a-a881cd8d74f8" + } + ], + "ownedSubsetting": [ + { + "@id": "a505bff6-1b93-5a91-a49a-a881cd8d74f8" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [ + { + "@id": "86bfb0af-1b47-550c-9439-458329c0a722" + } + ], + "ownedUnioning": [], + "owner": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningDefinition": null, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094" + }, + "owningNamespace": { + "@id": "d34f71f6-516c-5046-897d-4ee0a36ad111" + }, + "owningRelationship": { + "@id": "3675ed7f-88a5-5418-8afb-14956897c094" + }, + "owningType": null, + "owningUsage": null, + "parameter": [], + "portionKind": null, + "predicate": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "qualifiedName": "SatisfyCases::mission", + "reqId": null, + "requiredConstraint": [], + "requirementDefinition": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "result": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "shortName": null, + "stakeholderParameter": [], + "subjectParameter": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "text": [], + "textualRepresentation": [], + "type": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "unioningType": [], + "usage": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "86bfb0af-1b47-550c-9439-458329c0a722", + "@type": "FeatureTyping", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "86bfb0af-1b47-550c-9439-458329c0a722", + "general": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningRelationship": null, + "owningType": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "shortName": null, + "source": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "specific": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "target": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "textualRepresentation": [], + "type": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "typedFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + }, + { + "@id": "15039928-a578-5415-8fa9-34111b0058a5", + "@type": "FeatureMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "15039928-a578-5415-8fa9-34111b0058a5", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "memberElementId": "6e14b85e-4d0f-54e2-b311-0735f5038532", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "ownedMemberElementId": "6e14b85e-4d0f-54e2-b311-0735f5038532", + "ownedMemberFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningRelationship": null, + "owningType": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "shortName": null, + "source": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "target": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532", + "@type": "SatisfyRequirementUsage", + "actorParameter": [], + "aliasIds": [], + "assertedConstraint": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "assumedConstraint": [], + "behavior": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "chainingFeature": [], + "constraintDefinition": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "differencingType": [], + "directedFeature": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "directedUsage": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "direction": null, + "documentation": [], + "elementId": "6e14b85e-4d0f-54e2-b311-0735f5038532", + "endFeature": [], + "endOwningType": null, + "feature": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "featureMembership": [ + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + } + ], + "featureTarget": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "featuringType": [], + "framedConcern": [], + "function": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "importedMembership": [], + "individualDefinition": null, + "inheritedFeature": [], + "inheritedMembership": [], + "input": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "intersectingType": [], + "isAbstract": false, + "isComposite": true, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isIndividual": false, + "isLibraryElement": false, + "isModelLevelEvaluable": false, + "isNegated": false, + "isOrdered": false, + "isPortion": false, + "isReference": false, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "membership": [ + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + } + ], + "multiplicity": null, + "name": null, + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "occurrenceDefinition": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "ownedEndFeature": [], + "ownedFeature": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [ + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + } + ], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "ownedMembership": [ + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": { + "@id": "9f43e401-7f3a-5c26-8293-fb72b44140cd" + }, + "ownedRelationship": [ + { + "@id": "9f43e401-7f3a-5c26-8293-fb72b44140cd" + }, + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + }, + { + "@id": "2494131d-752c-5608-8e5b-55148d57597c" + } + ], + "ownedSpecialization": [ + { + "@id": "9f43e401-7f3a-5c26-8293-fb72b44140cd" + }, + { + "@id": "2494131d-752c-5608-8e5b-55148d57597c" + } + ], + "ownedSubsetting": [ + { + "@id": "9f43e401-7f3a-5c26-8293-fb72b44140cd" + }, + { + "@id": "2494131d-752c-5608-8e5b-55148d57597c" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + }, + "owningMembership": { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + }, + "owningNamespace": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningRelationship": { + "@id": "15039928-a578-5415-8fa9-34111b0058a5" + }, + "owningType": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningUsage": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "parameter": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "portionKind": null, + "predicate": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "qualifiedName": null, + "reqId": null, + "requiredConstraint": [], + "requirementDefinition": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "result": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "satisfiedRequirement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "satisfyingFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "shortName": null, + "stakeholderParameter": [], + "subjectParameter": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "text": [], + "textualRepresentation": [], + "type": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "unioningType": [], + "usage": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "variant": [], + "variantMembership": [] + }, + { + "@id": "9f43e401-7f3a-5c26-8293-fb72b44140cd", + "@type": "ReferenceSubsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "9f43e401-7f3a-5c26-8293-fb72b44140cd", + "general": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningRelationship": null, + "owningType": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "qualifiedName": null, + "referencedFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "referencingFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "relatedElement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "shortName": null, + "source": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "specific": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "subsettedFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "subsettingFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "target": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "textualRepresentation": [] + }, + { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627", + "@type": "SubjectMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "64bfa91c-ef78-5f1a-a881-9bc957184627", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "memberElementId": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6", + "memberName": "subj", + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "ownedMemberElementId": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6", + "ownedMemberFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "ownedMemberName": "subj", + "ownedMemberParameter": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "ownedRelationship": [], + "ownedSubjectParameter": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningRelationship": null, + "owningType": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "shortName": null, + "source": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "target": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6", + "@type": "ReferenceUsage", + "aliasIds": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "definition": [], + "differencingType": [], + "directedFeature": [], + "directedUsage": [], + "direction": null, + "documentation": [], + "elementId": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isReference": null, + "isSufficient": false, + "isUnique": true, + "isVariable": null, + "isVariation": false, + "mayTimeVary": null, + "member": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "membership": [ + { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591" + } + ], + "multiplicity": null, + "name": "subj", + "nestedAction": [], + "nestedAllocation": [], + "nestedAnalysisCase": [], + "nestedAttribute": [], + "nestedCalculation": [], + "nestedCase": [], + "nestedConcern": [], + "nestedConnection": [], + "nestedConstraint": [], + "nestedEnumeration": [], + "nestedFlow": [], + "nestedInterface": [], + "nestedItem": [], + "nestedMetadata": [], + "nestedOccurrence": [], + "nestedPart": [], + "nestedPort": [], + "nestedReference": [], + "nestedRendering": [], + "nestedRequirement": [], + "nestedState": [], + "nestedTransition": [], + "nestedUsage": [], + "nestedUseCase": [], + "nestedVerificationCase": [], + "nestedView": [], + "nestedViewpoint": [], + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "ownedMembership": [ + { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591" + } + ], + "ownedRedefinition": [ + { + "@id": "857a11a4-b149-5d64-9b55-08f678b4ff76" + } + ], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591" + }, + { + "@id": "f5d4879c-2882-5d07-921f-e6ad667a0844" + }, + { + "@id": "857a11a4-b149-5d64-9b55-08f678b4ff76" + } + ], + "ownedSpecialization": [ + { + "@id": "f5d4879c-2882-5d07-921f-e6ad667a0844" + }, + { + "@id": "857a11a4-b149-5d64-9b55-08f678b4ff76" + } + ], + "ownedSubsetting": [ + { + "@id": "f5d4879c-2882-5d07-921f-e6ad667a0844" + }, + { + "@id": "857a11a4-b149-5d64-9b55-08f678b4ff76" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningDefinition": null, + "owningFeatureMembership": { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + }, + "owningMembership": { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + }, + "owningNamespace": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningRelationship": { + "@id": "64bfa91c-ef78-5f1a-a881-9bc957184627" + }, + "owningType": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningUsage": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [], + "usage": [], + "variant": [], + "variantMembership": [] + }, + { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591", + "@type": "FeatureValue", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ae893f09-88aa-528e-acfb-afc49d807591", + "featureWithValue": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "isDefault": false, + "isImplied": false, + "isImpliedIncluded": true, + "isInitial": false, + "isLibraryElement": false, + "memberElement": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "memberElementId": "19536408-4501-523c-86b6-c2875600c87b", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "ownedMemberElementId": "19536408-4501-523c-86b6-c2875600c87b", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "shortName": null, + "source": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "target": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "textualRepresentation": [], + "value": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "visibility": "public" + }, + { + "@id": "19536408-4501-523c-86b6-c2875600c87b", + "@type": "FeatureReferenceExpression", + "aliasIds": [], + "behavior": [], + "chainingFeature": [], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "19536408-4501-523c-86b6-c2875600c87b", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "featuringType": [], + "function": null, + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isModelLevelEvaluable": true, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "membership": [ + { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0" + } + ], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "ownedMembership": [ + { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0" + } + ], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0" + }, + { + "@id": "269690c0-6bd8-59e6-be7d-194fdccbdb1e" + } + ], + "ownedSpecialization": [ + { + "@id": "269690c0-6bd8-59e6-be7d-194fdccbdb1e" + } + ], + "ownedSubsetting": [ + { + "@id": "269690c0-6bd8-59e6-be7d-194fdccbdb1e" + } + ], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591" + }, + "owningNamespace": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningRelationship": { + "@id": "ae893f09-88aa-528e-acfb-afc49d807591" + }, + "owningType": null, + "parameter": [], + "qualifiedName": null, + "referent": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "result": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "shortName": null, + "textualRepresentation": [], + "type": [], + "unioningType": [] + }, + { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0", + "@type": "OwningMembership", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0", + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "memberElement": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "memberElementId": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669", + "memberName": null, + "memberShortName": null, + "membershipOwningNamespace": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedMemberElement": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "ownedMemberElementId": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669", + "ownedMemberName": null, + "ownedMemberShortName": null, + "ownedRelatedElement": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "shortName": null, + "source": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "target": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "textualRepresentation": [], + "visibility": "public" + }, + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669", + "@type": "Feature", + "aliasIds": [], + "chainingFeature": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "crossFeature": null, + "declaredName": null, + "declaredShortName": null, + "differencingType": [], + "directedFeature": [], + "direction": null, + "documentation": [], + "elementId": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669", + "endFeature": [], + "endOwningType": null, + "feature": [], + "featureMembership": [], + "featureTarget": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "featuringType": [], + "importedMembership": [], + "inheritedFeature": [], + "inheritedMembership": [], + "input": [], + "intersectingType": [], + "isAbstract": false, + "isComposite": false, + "isConjugated": false, + "isConstant": false, + "isDerived": false, + "isEnd": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "isOrdered": false, + "isPortion": false, + "isSufficient": false, + "isUnique": true, + "isVariable": false, + "member": [], + "membership": [], + "multiplicity": null, + "name": null, + "output": [], + "ownedAnnotation": [], + "ownedConjugator": null, + "ownedCrossSubsetting": null, + "ownedDifferencing": [], + "ownedDisjoining": [], + "ownedElement": [], + "ownedEndFeature": [], + "ownedFeature": [], + "ownedFeatureChaining": [ + { + "@id": "da56ac4d-c8c1-5cd8-b791-613141eb6915" + }, + { + "@id": "b356fc7d-d48a-5e84-916a-4bd42b47b0e7" + } + ], + "ownedFeatureInverting": [], + "ownedFeatureMembership": [], + "ownedImport": [], + "ownedIntersecting": [], + "ownedMember": [], + "ownedMembership": [], + "ownedRedefinition": [], + "ownedReferenceSubsetting": null, + "ownedRelationship": [ + { + "@id": "da56ac4d-c8c1-5cd8-b791-613141eb6915" + }, + { + "@id": "b356fc7d-d48a-5e84-916a-4bd42b47b0e7" + } + ], + "ownedSpecialization": [], + "ownedSubsetting": [], + "ownedTypeFeaturing": [], + "ownedTyping": [], + "ownedUnioning": [], + "owner": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "owningFeatureMembership": null, + "owningMembership": { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0" + }, + "owningNamespace": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "owningRelationship": { + "@id": "8dec8a0b-91dd-5cbe-a500-63ce23b855f0" + }, + "owningType": null, + "qualifiedName": null, + "shortName": null, + "textualRepresentation": [], + "type": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "unioningType": [] + }, + { + "@id": "da56ac4d-c8c1-5cd8-b791-613141eb6915", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "da56ac4d-c8c1-5cd8-b791-613141eb6915", + "featureChained": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "shortName": null, + "source": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "target": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "b356fc7d-d48a-5e84-916a-4bd42b47b0e7", + "@type": "FeatureChaining", + "aliasIds": [], + "chainingFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "b356fc7d-d48a-5e84-916a-4bd42b47b0e7", + "featureChained": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "isImplied": false, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + "owningRelationship": null, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + }, + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "shortName": null, + "source": [ + { + "@id": "2a9feb78-8ec1-52d7-a5bf-3b2adeb3d669" + } + ], + "target": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "textualRepresentation": [] + }, + { + "@id": "4ca9c4a5-5981-5ede-9c5d-fcdc1c787d7a", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "4ca9c4a5-5981-5ede-9c5d-fcdc1c787d7a", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "owningRelationship": null, + "owningType": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + } + ], + "specific": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "subclassifier": { + "@id": "f7e7d98d-2960-5f44-88a5-f76924c19597" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "8b09ec52-e5fe-5160-913f-334be332898c", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "8b09ec52-e5fe-5160-913f-334be332898c", + "general": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "owningRelationship": null, + "owningType": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "shortName": null, + "source": [ + { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + } + ], + "specific": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "subsettedFeature": { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + }, + "subsettingFeature": { + "@id": "ee07e7cd-9d04-587e-a211-c7fb4dabbbde" + }, + "target": [ + { + "@id": "a44baa93-a4d0-535d-b879-44a30575f348" + } + ], + "textualRepresentation": [] + }, + { + "@id": "6d09e68c-8e5d-5618-b54c-a90f054d6e23", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "6d09e68c-8e5d-5618-b54c-a90f054d6e23", + "general": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "owningRelationship": null, + "owningType": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "shortName": null, + "source": [ + { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + } + ], + "specific": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "subclassifier": { + "@id": "2d014161-d2a0-590a-9330-3f63dacbab49" + }, + "superclassifier": { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + }, + "target": [ + { + "@id": "0774a545-39e3-5bc1-9607-63beabc6bf65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "ef4923e3-ec13-5a8b-adfb-d719cc3c9af8", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "ef4923e3-ec13-5a8b-adfb-d719cc3c9af8", + "general": { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "owningRelationship": null, + "owningType": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + } + ], + "shortName": null, + "source": [ + { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + } + ], + "specific": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "subsettedFeature": { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + }, + "subsettingFeature": { + "@id": "19b04e5e-f144-5c01-8bc4-43338c0c9c65" + }, + "target": [ + { + "@id": "0c6a9942-4bb9-58da-8344-57ecd220d4de" + } + ], + "textualRepresentation": [] + }, + { + "@id": "43bca579-d715-521b-a6bf-b55b626f0e69", + "@type": "Subclassification", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "43bca579-d715-521b-a6bf-b55b626f0e69", + "general": { + "@id": "e6c0a087-dffc-5a7a-872b-367adf7dcf4c" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningClassifier": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "owningRelationship": null, + "owningType": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + { + "@id": "e6c0a087-dffc-5a7a-872b-367adf7dcf4c" + } + ], + "shortName": null, + "source": [ + { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + } + ], + "specific": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "subclassifier": { + "@id": "9591768d-756a-55a2-a746-66a99cebffad" + }, + "superclassifier": { + "@id": "e6c0a087-dffc-5a7a-872b-367adf7dcf4c" + }, + "target": [ + { + "@id": "e6c0a087-dffc-5a7a-872b-367adf7dcf4c" + } + ], + "textualRepresentation": [] + }, + { + "@id": "a505bff6-1b93-5a91-a49a-a881cd8d74f8", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "a505bff6-1b93-5a91-a49a-a881cd8d74f8", + "general": { + "@id": "8bad436f-8f9a-5197-b184-58a7e0145d9d" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "owningRelationship": null, + "owningType": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + { + "@id": "8bad436f-8f9a-5197-b184-58a7e0145d9d" + } + ], + "shortName": null, + "source": [ + { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + } + ], + "specific": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "subsettedFeature": { + "@id": "8bad436f-8f9a-5197-b184-58a7e0145d9d" + }, + "subsettingFeature": { + "@id": "ddf58eb2-e917-525b-80bf-be2b5da6dec8" + }, + "target": [ + { + "@id": "8bad436f-8f9a-5197-b184-58a7e0145d9d" + } + ], + "textualRepresentation": [] + }, + { + "@id": "2494131d-752c-5608-8e5b-55148d57597c", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "2494131d-752c-5608-8e5b-55148d57597c", + "general": { + "@id": "2d1053c8-d4eb-5f2c-92d4-917c1228de5c" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "owningRelationship": null, + "owningType": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + { + "@id": "2d1053c8-d4eb-5f2c-92d4-917c1228de5c" + } + ], + "shortName": null, + "source": [ + { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + } + ], + "specific": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "subsettedFeature": { + "@id": "2d1053c8-d4eb-5f2c-92d4-917c1228de5c" + }, + "subsettingFeature": { + "@id": "6e14b85e-4d0f-54e2-b311-0735f5038532" + }, + "target": [ + { + "@id": "2d1053c8-d4eb-5f2c-92d4-917c1228de5c" + } + ], + "textualRepresentation": [] + }, + { + "@id": "f5d4879c-2882-5d07-921f-e6ad667a0844", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "f5d4879c-2882-5d07-921f-e6ad667a0844", + "general": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningRelationship": null, + "owningType": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "shortName": null, + "source": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "specific": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "subsettedFeature": { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + }, + "subsettingFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "target": [ + { + "@id": "3176ab6a-8d7b-5e14-b263-57bd30f77f78" + } + ], + "textualRepresentation": [] + }, + { + "@id": "857a11a4-b149-5d64-9b55-08f678b4ff76", + "@type": "Redefinition", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "857a11a4-b149-5d64-9b55-08f678b4ff76", + "general": { + "@id": "dcfd8195-70ca-5d3b-9d5c-2293fe0cdc65" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "owningRelationship": null, + "owningType": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "qualifiedName": null, + "redefinedFeature": { + "@id": "dcfd8195-70ca-5d3b-9d5c-2293fe0cdc65" + }, + "redefiningFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "relatedElement": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + { + "@id": "dcfd8195-70ca-5d3b-9d5c-2293fe0cdc65" + } + ], + "shortName": null, + "source": [ + { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + } + ], + "specific": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "subsettedFeature": { + "@id": "dcfd8195-70ca-5d3b-9d5c-2293fe0cdc65" + }, + "subsettingFeature": { + "@id": "6d49395b-17f9-5a3e-9611-e02ba7ab60e6" + }, + "target": [ + { + "@id": "dcfd8195-70ca-5d3b-9d5c-2293fe0cdc65" + } + ], + "textualRepresentation": [] + }, + { + "@id": "269690c0-6bd8-59e6-be7d-194fdccbdb1e", + "@type": "Subsetting", + "aliasIds": [], + "declaredName": null, + "declaredShortName": null, + "documentation": [], + "elementId": "269690c0-6bd8-59e6-be7d-194fdccbdb1e", + "general": { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + }, + "isImplied": true, + "isImpliedIncluded": true, + "isLibraryElement": false, + "name": null, + "ownedAnnotation": [], + "ownedElement": [], + "ownedRelatedElement": [], + "ownedRelationship": [], + "owner": null, + "owningFeature": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "owningMembership": null, + "owningNamespace": null, + "owningRelatedElement": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "owningRelationship": null, + "owningType": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "qualifiedName": null, + "relatedElement": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + } + ], + "shortName": null, + "source": [ + { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + } + ], + "specific": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "subsettedFeature": { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + }, + "subsettingFeature": { + "@id": "19536408-4501-523c-86b6-c2875600c87b" + }, + "target": [ + { + "@id": "c590aa58-6c78-5aeb-b1c9-a784abcb2e29" + } + ], + "textualRepresentation": [] + } +] diff --git a/tests/export/toolkit_json_import_test.go b/tests/export/toolkit_json_import_test.go index cedf9ab290..9fd36baaff 100644 --- a/tests/export/toolkit_json_import_test.go +++ b/tests/export/toolkit_json_import_test.go @@ -64,6 +64,13 @@ func TestToolkitFlowEndAndPayload(t *testing.T) { } } +func TestToolkitSatisfyByRoundTripsAsReference(t *testing.T) { + out := decodeToolkitFixture(t, "satisfy_by.toolkit.full.json", nil) + if !strings.Contains(string(out), "satisfy mission by vehicle.engine;") { + t.Fatalf("the satisfy subject was not written as a `by` reference:\n%s", out) + } +} + func TestToolkitFlowEndRefusesUnrepresentableDetails(t *testing.T) { for _, tc := range []struct { name string @@ -140,6 +147,39 @@ func TestToolkitTransitionClauses(t *testing.T) { t.Fatalf("the entry was not kept as the positional `first start then x;` form:\n%s", text) } +func TestToolkitTransitionSourceUsesRedefinitionTarget(t *testing.T) { + var objects []map[string]any + if err := json.Unmarshal(toolkitFixture(t, "transitions.toolkit.full.json"), &objects); err != nil { + t.Fatal(err) + } + changed := false + for _, object := range objects { + if object["@type"] == "ReferenceUsage" && object["name"] == "transitionLinkSource" { + object["name"] = "derivedNameChanged" + changed = true + break + } + } + if !changed { + t.Fatal("the toolkit transition source parameter was not found") + } + data, err := json.Marshal(objects) + if err != nil { + t.Fatal(err) + } + graph, err := export.ReadAPIJSON(data) + if err != nil { + t.Fatalf("ReadAPIJSON: %v", err) + } + out, err := export.ToSysML(graph) + if err != nil { + t.Fatalf("ToSysML: %v", err) + } + if !bytes.Contains(out, []byte("transition triggered first x accept Go then y;")) { + t.Fatalf("the source was not recovered from its implied Redefinition target:\n%s", out) + } +} + func TestToolkitInferredSuccessionClause(t *testing.T) { out := decodeToolkitFixture(t, "successions.toolkit.full.json", nil) want := toolkitFixture(t, "successions.golden.sysml") From 27ad3619446fd98a51a0469cf4bad165992cef94 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 01:47:59 +0000 Subject: [PATCH 04/10] fix(frontend): parse converted JSON as SysML Co-Authored-By: jason.han --- cmd/sysml/convert_test.go | 34 +++++++++++++++++++++++++++ internal/frontend/repl/load.go | 9 +++++-- internal/frontend/repl/session.go | 14 +++++++++-- internal/syntax/source/kind.go | 8 +++---- internal/syntax/source/source_test.go | 8 ------- 5 files changed, 56 insertions(+), 17 deletions(-) diff --git a/cmd/sysml/convert_test.go b/cmd/sysml/convert_test.go index cdc4c279f8..ed26632b55 100644 --- a/cmd/sysml/convert_test.go +++ b/cmd/sysml/convert_test.go @@ -12,6 +12,7 @@ import ( "sync" "testing" + "github.com/Open-MBEE/OpenSysML/internal/translate/convert" "github.com/Open-MBEE/OpenSysML/internal/translate/migrate" "github.com/Open-MBEE/OpenSysML/tests/testutil/gobuild" ) @@ -143,6 +144,39 @@ func TestConvertAPIJSONLibraryFallbackWarnsOnStderr(t *testing.T) { } } +func TestConvertRecordedReportsAPIJSONWarning(t *testing.T) { + stdout, err := os.CreateTemp(t.TempDir(), "stdout") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = stdout.Close() }) + stderr, err := os.CreateTemp(t.TempDir(), "stderr") + if err != nil { + t.Fatal(err) + } + t.Cleanup(func() { _ = stderr.Close() }) + oldStdout, oldStderr := os.Stdout, os.Stderr + os.Stdout, os.Stderr = stdout, stderr + defer func() { + os.Stdout, os.Stderr = oldStdout, oldStderr + }() + + status, err := convertRecorded(apiJSONFixture(t, "library_identity.toolkit.full.json"), convert.FormatSysML) + if err != nil || status != 0 { + t.Fatalf("recorded conversion returned status %d, error %v", status, err) + } + if err := stderr.Sync(); err != nil { + t.Fatal(err) + } + warnings, err := os.ReadFile(stderr.Name()) + if err != nil { + t.Fatal(err) + } + if !strings.Contains(string(warnings), "warning: the library element") { + t.Fatalf("recorded conversion omitted the library warning:\n%s", warnings) + } +} + // TestConvertFlagOrder checks that the model may be named before or after the // flags that apply to it, since Go's flag package stops at the first file name // unless the arguments are reordered. diff --git a/internal/frontend/repl/load.go b/internal/frontend/repl/load.go index dfa0b8c9a8..4a92c038a6 100644 --- a/internal/frontend/repl/load.go +++ b/internal/frontend/repl/load.go @@ -5,6 +5,7 @@ import ( "fmt" "io/fs" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/translate/convert" "github.com/Open-MBEE/OpenSysML/internal/workspace/project" ) @@ -125,13 +126,17 @@ func (s *Session) readSources(paths []string) ([]SourceFile, error) { return nil, err } var warnings []string - text, _, err := convert.ModelSource(name, data, func(message string) { + text, converted, err := convert.ModelSource(name, data, func(message string) { warnings = append(warnings, message) }) if err != nil { return nil, fmt.Errorf("cannot convert %s: %w", name, err) } - files = append(files, SourceFile{Name: name, Text: string(text), Warnings: warnings}) + var kind source.Kind + if converted { + kind = source.KindSysML + } + files = append(files, SourceFile{Name: name, Text: string(text), Kind: kind, Warnings: warnings}) } return files, nil } diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go index df57e04e0a..bc869bc1be 100644 --- a/internal/frontend/repl/session.go +++ b/internal/frontend/repl/session.go @@ -426,8 +426,17 @@ type parsed struct { // preparse parses src as the submission from origin, and probes whether it // closes its own text. func preparse(origin, src string) parsed { + return preparseWithKind(origin, src, source.KindUnknown) +} + +func preparseWithKind(origin, src string, kind source.Kind) parsed { doc := parseDocName(origin) - p := parser.New(source.New(doc, []byte(src))) + data := []byte(src) + sourceFile := source.New(doc, data) + if kind != source.KindUnknown { + sourceFile = source.NewWithKind(doc, data, kind) + } + p := parser.New(sourceFile) return parsed{p: p, root: p.ParseFile(), closes: closesItsOwnText(doc, src)} } @@ -837,6 +846,7 @@ func (s *Session) Submit(src string) Result { type SourceFile struct { Name string Text string + Kind source.Kind Warnings []string } @@ -903,7 +913,7 @@ func (s *Session) submitEach(files []SourceFile) (res Result, byFile [][]string, byFile = make([][]string, len(files)) parses := make([]parsed, len(files)) model.ParallelFor(s.jobs, len(files), func(i int) { - parses[i] = preparse(files[i].Name, files[i].Text) + parses[i] = preparseWithKind(files[i].Name, files[i].Text, files[i].Kind) }) for i, f := range files { names, dropped := s.acceptParsed(f.Name, f.Text, parses[i]) diff --git a/internal/syntax/source/kind.go b/internal/syntax/source/kind.go index 5ffc76ec57..617ec0496f 100644 --- a/internal/syntax/source/kind.go +++ b/internal/syntax/source/kind.go @@ -2,7 +2,6 @@ package source import ( "path/filepath" - "strings" ) // Kind is the language a source is parsed as. The two languages share a lexer @@ -30,11 +29,10 @@ func (k Kind) String() string { } } -// KindOf reports the language of a file name by its extension. API JSON files -// are converted to SysML notation before they are parsed. +// KindOf reports the language of a file name by its extension. func KindOf(name string) Kind { - switch strings.ToLower(filepath.Ext(name)) { - case ".sysml", ".json": + switch filepath.Ext(name) { + case ".sysml": return KindSysML case ".kerml": return KindKerML diff --git a/internal/syntax/source/source_test.go b/internal/syntax/source/source_test.go index f4d6eca27d..95116075da 100644 --- a/internal/syntax/source/source_test.go +++ b/internal/syntax/source/source_test.go @@ -2,14 +2,6 @@ package source import "testing" -func TestKindOfAPIJSONIsSysML(t *testing.T) { - for _, name := range []string{"model.json", "model.JSON"} { - if got := KindOf(name); got != KindSysML { - t.Errorf("KindOf(%q) = %v, want SysML", name, got) - } - } -} - func TestSpanText(t *testing.T) { sf := New("test.sysml", []byte("part def Engine;")) sp := Span{Offset: 9, Len: 6} From f2dc2e16130bef2ab5237cdf4739e13bb1b8e6df Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 02:15:33 +0000 Subject: [PATCH 05/10] fix(frontend): keep JSON conversion out of the REPL core Co-Authored-By: jason.han --- cmd/sysml/api_json_load_test.go | 14 ++++++++++++ cmd/sysml/main.go | 2 +- internal/frontend/repl/load.go | 15 ++++++++----- internal/frontend/repl/load_test.go | 4 +++- internal/frontend/repl/session.go | 35 ++++++++++++++++++++--------- 5 files changed, 52 insertions(+), 18 deletions(-) diff --git a/cmd/sysml/api_json_load_test.go b/cmd/sysml/api_json_load_test.go index 1288a4740d..ca4c09dab2 100644 --- a/cmd/sysml/api_json_load_test.go +++ b/cmd/sysml/api_json_load_test.go @@ -59,3 +59,17 @@ func TestValidateUnconvertibleAPIJSONNamesFile(t *testing.T) { t.Fatalf("failed conversion did not name %s (exit %d):\n%s", path, result.status, result.output()) } } + +func TestSessionLoadsAPIJSONFiles(t *testing.T) { + session := newSession() + report, err := session.LoadPathsReport([]string{apiJSONFixture(t, "library_identity.toolkit.full.json")}) + if err != nil { + t.Fatal(err) + } + if report.Errors || len(report.Declared) == 0 { + t.Fatalf("converted API JSON did not load cleanly: %+v", report) + } + if !strings.Contains(strings.Join(report.Found, "\n"), "warning: the library element") { + t.Fatalf("load report omitted the conversion warning: %v", report.Found) + } +} diff --git a/cmd/sysml/main.go b/cmd/sysml/main.go index 203b8cce23..ab95a5b4c6 100644 --- a/cmd/sysml/main.go +++ b/cmd/sysml/main.go @@ -758,7 +758,7 @@ func resolveRunBounds() int { // newSession returns a session in the output modes the flags asked for, under // the run bounds resolved at startup. func newSession() *repl.Session { - sess := repl.NewSession() + sess := repl.NewSessionWithSourceConverter(convert.ModelSource) sess.SetToolVersion("sysml " + Version) if err := sess.SetBudgets(budgets); err != nil { // Unreachable: budgets are validated in main before any session exists. diff --git a/internal/frontend/repl/load.go b/internal/frontend/repl/load.go index 4a92c038a6..8694396419 100644 --- a/internal/frontend/repl/load.go +++ b/internal/frontend/repl/load.go @@ -6,7 +6,6 @@ import ( "io/fs" "github.com/Open-MBEE/OpenSysML/internal/syntax/source" - "github.com/Open-MBEE/OpenSysML/internal/translate/convert" "github.com/Open-MBEE/OpenSysML/internal/workspace/project" ) @@ -126,11 +125,15 @@ func (s *Session) readSources(paths []string) ([]SourceFile, error) { return nil, err } var warnings []string - text, converted, err := convert.ModelSource(name, data, func(message string) { - warnings = append(warnings, message) - }) - if err != nil { - return nil, fmt.Errorf("cannot convert %s: %w", name, err) + text, converted := data, false + if s.sourceConverter != nil { + var err error + text, converted, err = s.sourceConverter(name, data, func(message string) { + warnings = append(warnings, message) + }) + if err != nil { + return nil, fmt.Errorf("cannot convert %s: %w", name, err) + } } var kind source.Kind if converted { diff --git a/internal/frontend/repl/load_test.go b/internal/frontend/repl/load_test.go index 3a4675a355..a81ab89829 100644 --- a/internal/frontend/repl/load_test.go +++ b/internal/frontend/repl/load_test.go @@ -5,6 +5,8 @@ import ( "path/filepath" "strings" "testing" + + "github.com/Open-MBEE/OpenSysML/internal/translate/convert" ) func writeFile(t *testing.T, path, content string) string { @@ -64,7 +66,7 @@ func TestLoadingADirectoryResolvesRegardlessOfFileName(t *testing.T) { func TestLoadPathsReportConvertsAPIJSONAndReportsWarnings(t *testing.T) { path := filepath.Join("..", "..", "..", "tests", "export", "testdata", "interchange", "library_identity.toolkit.full.json") - session := NewSession() + session := NewSessionWithSourceConverter(convert.ModelSource) report, err := session.LoadPathsReport([]string{path}) if err != nil { diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go index bc869bc1be..fb7dbf98a8 100644 --- a/internal/frontend/repl/session.go +++ b/internal/frontend/repl/session.go @@ -69,6 +69,9 @@ type snippet struct { diags []diag.Diagnostic } +// SourceConverter transforms a named source file before the REPL parses it. +type SourceConverter func(name string, data []byte, warn func(string)) (text []byte, converted bool, err error) + // Session accumulates submissions: what is typed into the transcript document, // and each loaded file into a document of its own. type Session struct { @@ -79,9 +82,10 @@ type Session struct { mu sync.Mutex state sync.Mutex - ws *model.Workspace - snippets []snippet - version int + ws *model.Workspace + sourceConverter SourceConverter + snippets []snippet + version int // Runtime execution context rtCtx *runtime.Context @@ -290,14 +294,25 @@ func (s *stateSession) selfOf() string { // NewSession returns a session over a fresh workspace. func NewSession() *Session { + return newSession(nil) +} + +// NewSessionWithSourceConverter returns a fresh session that converts named +// source files before parsing them. +func NewSessionWithSourceConverter(converter SourceConverter) *Session { + return newSession(converter) +} + +func newSession(converter SourceConverter) *Session { s := &Session{ - ws: model.NewWorkspace(), - instances: make(map[string]*runtime.Instance), - budgets: runtime.DefaultBudgets(), - engines: engines.Default(), - verbosity: VerbosityNormal, - toolVersion: "sysml dev", - now: time.Now, + ws: model.NewWorkspace(), + sourceConverter: converter, + instances: make(map[string]*runtime.Instance), + budgets: runtime.DefaultBudgets(), + engines: engines.Default(), + verbosity: VerbosityNormal, + toolVersion: "sysml dev", + now: time.Now, } s.setJobs(analysis.DefaultJobs()) return s From 8e167dcae5e5dfc07616d7a6245b79cba70427dc Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 02:37:35 +0000 Subject: [PATCH 06/10] fix(grpc): keep default model hashes stable Co-Authored-By: jason.han --- internal/frontend/grpc/service.go | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/internal/frontend/grpc/service.go b/internal/frontend/grpc/service.go index 8506086fd6..b8909f12e3 100644 --- a/internal/frontend/grpc/service.go +++ b/internal/frontend/grpc/service.go @@ -771,9 +771,11 @@ func (s *Service) parseModel(inputs []sourceInput, mode diag.ConformanceMode) (s for _, field := range []string{input.name, input.language, input.content} { fmt.Fprintf(&key, "\x00%d\x00%s", len(field), field) } - fmt.Fprintf(&key, "\x00%d", len(input.warnings)) - for _, warning := range input.warnings { - fmt.Fprintf(&key, "\x00%d\x00%s", len(warning), warning) + if len(input.warnings) > 0 { + fmt.Fprintf(&key, "\x00%d", len(input.warnings)) + for _, warning := range input.warnings { + fmt.Fprintf(&key, "\x00%d\x00%s", len(warning), warning) + } } } modelHash := computeHash(key.String()) From 07ba0f6b72f1fa4036a7655bbacd22aa979bba43 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 04:37:53 +0000 Subject: [PATCH 07/10] fix(repl): keep converted JSON documents in SysML Co-Authored-By: jason.han --- internal/frontend/repl/load_test.go | 47 ++++++++++++ internal/frontend/repl/merge.go | 12 +-- internal/frontend/repl/notices.go | 3 +- internal/frontend/repl/oslc_query.go | 3 +- internal/frontend/repl/print.go | 2 +- internal/frontend/repl/session.go | 28 ++++--- internal/frontend/repl/view.go | 4 +- internal/semantic/symbols/index.go | 5 ++ internal/workspace/model/batch.go | 22 ++++-- internal/workspace/model/batch_test.go | 74 ++++++++++++++++++- internal/workspace/model/document.go | 21 +++++- internal/workspace/model/document_test.go | 5 +- internal/workspace/model/hydrate.go | 20 +++-- internal/workspace/model/library_version.go | 2 +- .../workspace/model/library_version_test.go | 4 +- internal/workspace/model/record.go | 9 ++- internal/workspace/model/workspace.go | 8 +- 17 files changed, 216 insertions(+), 53 deletions(-) diff --git a/internal/frontend/repl/load_test.go b/internal/frontend/repl/load_test.go index a81ab89829..543ef4e58b 100644 --- a/internal/frontend/repl/load_test.go +++ b/internal/frontend/repl/load_test.go @@ -6,6 +6,8 @@ import ( "strings" "testing" + "github.com/Open-MBEE/OpenSysML/internal/syntax/ast" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/translate/convert" ) @@ -83,6 +85,51 @@ func TestLoadPathsReportConvertsAPIJSONAndReportsWarnings(t *testing.T) { } } +func TestLoadPathsReportKeepsConvertedSourceKind(t *testing.T) { + path := writeFile(t, filepath.Join(t.TempDir(), "model.json"), "API JSON") + text := []byte("package P { part all; }\n") + session := NewSessionWithSourceConverter(func(name string, data []byte, warn func(string)) ([]byte, bool, error) { + if filepath.Ext(name) != ".json" { + return data, false, nil + } + return text, true, nil + }) + + _, err := session.LoadPathsReport([]string{path}) + if err != nil { + t.Fatal(err) + } + doc := session.ws.Document(path) + if doc == nil { + t.Fatalf("workspace did not open %s", path) + } + if doc.Kind() != source.KindSysML { + t.Fatalf("document kind = %v, want SysML", doc.Kind()) + } + if len(doc.ParseDiagnostics) != 0 { + t.Fatalf("converted SysML has parse diagnostics: %v", doc.ParseDiagnostics) + } + if len(doc.AST.Members) != 1 { + t.Fatalf("converted SysML AST has %d root members, want one", len(doc.AST.Members)) + } + rootMember, ok := doc.AST.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("converted SysML root member = %T, want membership", doc.AST.Members[0]) + } + pkg, ok := rootMember.Member.(*ast.Package) + if !ok || len(pkg.Members) != 1 { + t.Fatalf("converted SysML AST has package members %v, want one package member", doc.AST.Members) + } + pkgMember, ok := pkg.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("converted SysML package member = %T, want membership", pkg.Members[0]) + } + usage, ok := pkgMember.Member.(*ast.Usage) + if !ok || usage.Ident.Name != "all" || usage.IsAll { + t.Fatalf("converted SysML part = %#v, want named `all` without the all modifier", pkg.Members[0]) + } +} + func TestLoadingADirectoryIgnoresJSONFiles(t *testing.T) { dir := t.TempDir() writeFile(t, filepath.Join(dir, "model.sysml"), "package OnlySysML { part def A; }\n") diff --git a/internal/frontend/repl/merge.go b/internal/frontend/repl/merge.go index b90c6157ae..9af6af562e 100644 --- a/internal/frontend/repl/merge.go +++ b/internal/frontend/repl/merge.go @@ -64,7 +64,7 @@ func (s *Session) mergeSubmission(src string, root *ast.RootNamespace, comments if sn.gen == s.version || sn.open || (sn.origin != "" && !s.recordMerge) { continue } - cand, ok := namedNamespace(sn.src, newDecl.name) + cand, ok := namedNamespace(sn.src, newDecl.name, sn.kind) // A different header is a different declaration, whatever it names: it // replaces the old one rather than adding to a body it did not write. if !ok || cand.header != newDecl.header { @@ -96,8 +96,8 @@ func (s *Session) mergeSubmission(src string, root *ast.RootNamespace, comments // A file's text is updated where it is, its origin and key kept, so // a later reload of the file still supersedes it; the submission's // own text is wholly inside it and is not appended again. - names := declaredNames(parser.New(source.New(parseDocName(sn.origin), []byte(merged))).ParseFile()) - s.snippets[i] = snippet{src: merged, names: names, origin: sn.origin, key: sn.key, gen: s.version, own: own} + names := declaredNames(parser.New(sourceForKind(parseDocName(sn.origin), []byte(merged), sn.kind)).ParseFile()) + s.snippets[i] = snippet{src: merged, names: names, origin: sn.origin, key: sn.key, kind: sn.kind, gen: s.version, own: own} return "", nil, dropReport{merged: true, decl: newDecl.desc, lost: replaced, gone: gone}, true, true } s.snippets = append(s.snippets[:i:i], s.snippets[i+1:]...) @@ -147,7 +147,7 @@ func (s *Session) reopenedNamespaces(key string, root *ast.RootNamespace) []drop if len(shared) == 0 { continue } - snRoot := parser.New(source.New(parseDocName(sn.origin), []byte(sn.src))).ParseFile() + snRoot := parser.New(sourceForKind(parseDocName(sn.origin), []byte(sn.src), sn.kind)).ParseFile() for _, name := range shared { if _, ok := namedNamespaceIn(sn.src, snRoot, name); ok { reopened[name] = true @@ -218,8 +218,8 @@ func namespaceDepth(src string, decl nsDecl, segs []string) int { // namedNamespace finds the namespace declaration of the given name in an // accepted snippet. It reports false unless exactly one member declares that // name, so an ambiguous snippet keeps the replacement behavior. -func namedNamespace(src, name string) (nsDecl, bool) { - return namedNamespaceIn(src, parser.New(source.New(docName, []byte(src))).ParseFile(), name) +func namedNamespace(src, name string, kind source.Kind) (nsDecl, bool) { + return namedNamespaceIn(src, parser.New(sourceForKind(docName, []byte(src), kind)).ParseFile(), name) } // namedNamespaceIn is namedNamespace over a parse the caller already has. diff --git a/internal/frontend/repl/notices.go b/internal/frontend/repl/notices.go index 071fd0ceac..0ef2a21be0 100644 --- a/internal/frontend/repl/notices.go +++ b/internal/frontend/repl/notices.go @@ -7,7 +7,6 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/syntax/ast" "github.com/Open-MBEE/OpenSysML/internal/syntax/parser" - "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/workspace/libs" ) @@ -68,7 +67,7 @@ func dropNotices(drops []dropReport) []string { // both the snippet's other top-level declarations and, for a re-declared // namespace, the members its new body does not declare again. func replacedReport(sn snippet, redeclared map[string]bool, newTop map[string]ast.Node) dropReport { - root := parser.New(source.New(parseDocName(sn.origin), []byte(sn.src))).ParseFile() + root := parser.New(sourceForKind(parseDocName(sn.origin), []byte(sn.src), sn.kind)).ParseFile() rep := dropReport{} if root == nil { return rep diff --git a/internal/frontend/repl/oslc_query.go b/internal/frontend/repl/oslc_query.go index 54a016c21c..77db3b3fad 100644 --- a/internal/frontend/repl/oslc_query.go +++ b/internal/frontend/repl/oslc_query.go @@ -10,7 +10,6 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/semantic/resolve" "github.com/Open-MBEE/OpenSysML/internal/semantic/semantics" "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols" - "github.com/Open-MBEE/OpenSysML/internal/syntax/source" ) // Query evaluates OSLC element-identification query text and renders one @@ -161,7 +160,7 @@ func (m *replQueryModel) positionalNames() { continue } docs = append(docs, replext.PositionalDocument{ - File: source.New(doc.Name, doc.Content), + File: sourceForKind(doc.Name, doc.Content, doc.Kind()), Root: root, }) } diff --git a/internal/frontend/repl/print.go b/internal/frontend/repl/print.go index a2dbd2b982..f8b7e1390f 100644 --- a/internal/frontend/repl/print.go +++ b/internal/frontend/repl/print.go @@ -67,7 +67,7 @@ func (s *Session) printElement(name string) ([]string, bool, error) { // session never read, or was restored from an index cache holding no tree. return []string{fmt.Sprintf("no notation to print for %s: this session declares it nowhere", shown)}, false, nil } - file := source.New(doc.Name, doc.Content) + file := sourceForKind(doc.Name, doc.Content, doc.Kind()) return replext.Notation().PrintElement(file, declarationSpan(sym), shown), false, nil } diff --git a/internal/frontend/repl/session.go b/internal/frontend/repl/session.go index fb7dbf98a8..6aafbac44c 100644 --- a/internal/frontend/repl/session.go +++ b/internal/frontend/repl/session.go @@ -47,6 +47,7 @@ func parseDocName(origin string) string { type snippet struct { src string names []string + kind source.Kind // origin is the file this snippet was read from, empty for a submission // typed at the prompt, and key identifies that file across the ways its path // can be written. @@ -427,7 +428,7 @@ func (s *Session) accept(origin, src string) { // A loaded file supersedes only itself and what the prompt said about the same // names, since several files of one model commonly open the same package. func (s *Session) acceptFrom(origin, src string) (declared []string, drops []dropReport) { - return s.acceptParsed(origin, src, preparse(origin, src)) + return s.acceptParsed(origin, src, preparse(origin, src), source.KindUnknown) } // parsed is what a submission's text parses to, taken before it is accepted so @@ -447,16 +448,19 @@ func preparse(origin, src string) parsed { func preparseWithKind(origin, src string, kind source.Kind) parsed { doc := parseDocName(origin) data := []byte(src) - sourceFile := source.New(doc, data) - if kind != source.KindUnknown { - sourceFile = source.NewWithKind(doc, data, kind) - } - p := parser.New(sourceFile) + p := parser.New(sourceForKind(doc, data, kind)) return parsed{p: p, root: p.ParseFile(), closes: closesItsOwnText(doc, src)} } +func sourceForKind(name string, data []byte, kind source.Kind) *source.SourceFile { + if kind == source.KindUnknown { + return source.New(name, data) + } + return source.NewWithKind(name, data, kind) +} + // acceptParsed is acceptFrom over a parse already taken. -func (s *Session) acceptParsed(origin, src string, pre parsed) (declared []string, drops []dropReport) { +func (s *Session) acceptParsed(origin, src string, pre parsed, kind source.Kind) (declared []string, drops []dropReport) { p, root := pre.p, pre.root names := declaredNames(root) declared = names @@ -483,6 +487,7 @@ func (s *Session) acceptParsed(origin, src string, pre parsed) (declared []strin src: src, origin: origin, key: key, + kind: kind, gen: s.version, open: true, diags: parser.AsDiagnostics(p.Diagnostics, p.Warnings), @@ -512,7 +517,7 @@ func (s *Session) acceptParsed(origin, src string, pre parsed) (declared []strin kept = append(kept, sn) } } - s.snippets = append(kept, snippet{src: src, names: names, origin: origin, key: key, gen: s.version}) + s.snippets = append(kept, snippet{src: src, names: names, origin: origin, key: key, kind: kind, gen: s.version}) return declared, append(drops, s.reopenedNamespaces(key, root)...) } if len(names) > 0 { @@ -549,6 +554,7 @@ func (s *Session) acceptParsed(origin, src string, pre parsed) (declared []strin src: comments + text, names: names, origin: origin, + kind: kind, gen: s.version, prefix: len(comments), own: mergedOwn, @@ -724,7 +730,7 @@ func (s *Session) openDocuments() { } live[sn.origin] = true if doc := s.ws.Document(sn.origin); doc == nil || doc.Version != sn.gen { - inputs = append(inputs, model.Input{Name: sn.origin, Content: []byte(sn.src), Version: sn.gen}) + inputs = append(inputs, model.Input{Name: sn.origin, Content: []byte(sn.src), Version: sn.gen, Kind: sn.kind}) } } for _, name := range s.ws.DocumentNames() { @@ -931,7 +937,7 @@ func (s *Session) submitEach(files []SourceFile) (res Result, byFile [][]string, parses[i] = preparseWithKind(files[i].Name, files[i].Text, files[i].Kind) }) for i, f := range files { - names, dropped := s.acceptParsed(f.Name, f.Text, parses[i]) + names, dropped := s.acceptParsed(f.Name, f.Text, parses[i], f.Kind) for _, name := range names { if !seen[name] { seen[name] = true @@ -1309,7 +1315,7 @@ func (s *Session) runtimeModel() (*runtime.Model, error) { // the line it was submitted on rather than a byte offset, and the buffer's // scope tree, so a carried object is rebound to the symbols the prompt reaches. for _, doc := range s.sessionDocs() { - model.RegisterSource(source.New(doc.Name, doc.Content)) + model.RegisterSource(sourceForKind(doc.Name, doc.Content, doc.Kind())) model.RegisterScope(doc.Scope) } return model, nil diff --git a/internal/frontend/repl/view.go b/internal/frontend/repl/view.go index 3ac4d05a4c..d8f8cb62b2 100644 --- a/internal/frontend/repl/view.go +++ b/internal/frontend/repl/view.go @@ -287,7 +287,7 @@ func (s *Session) sessionSourceText() view.SourceText { } files := make(map[string]*source.SourceFile, len(docs)) for _, doc := range docs { - files[doc.Name] = source.New(doc.Name, doc.Content) + files[doc.Name] = sourceForKind(doc.Name, doc.Content, doc.Kind()) } return source.TextOf(files, libs.Text(s.libSource)) } @@ -444,7 +444,7 @@ func (r *reportRuntime) runtime() (*runtime.Context, error) { model := runtime.NewModel(sem, resolver) model.SetExpressionParser(parser.ParseOneExpression) for _, doc := range r.session.sessionDocs() { - model.RegisterSource(source.New(doc.Name, doc.Content)) + model.RegisterSource(sourceForKind(doc.Name, doc.Content, doc.Kind())) } ctx := runtime.NewContext(model, r.session.budgets.MaxSteps) if err := ctx.SetBudgets(r.session.budgets); err != nil { diff --git a/internal/semantic/symbols/index.go b/internal/semantic/symbols/index.go index 805f37b21b..565ea7ed94 100644 --- a/internal/semantic/symbols/index.go +++ b/internal/semantic/symbols/index.go @@ -389,6 +389,11 @@ func (idx *Index) AddDocumentScope(name string, root *ast.RootNamespace, rs *Sco idx.addDocument(name, root, rs, source.KindOf(name), false) } +// AddDocumentScopeWithKind adds an existing scope tree and records its explicit language. +func (idx *Index) AddDocumentScopeWithKind(name string, root *ast.RootNamespace, rs *Scope, kind source.Kind) { + idx.addDocument(name, root, rs, kind, true) +} + // AddDocumentWithKind builds the scope tree for root and records its explicit // language, which is needed when the document name does not carry an extension. func (idx *Index) AddDocumentWithKind(name string, root *ast.RootNamespace, kind source.Kind) { diff --git a/internal/workspace/model/batch.go b/internal/workspace/model/batch.go index b00cf63d17..f5c7fea184 100644 --- a/internal/workspace/model/batch.go +++ b/internal/workspace/model/batch.go @@ -12,16 +12,19 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/semantic/resolve" "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols" "github.com/Open-MBEE/OpenSysML/internal/syntax/diag" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/workspace/libs" ) // Input is one document a batch opens: the name it is indexed under, its text -// and its version. A Transient input is a buffer no file holds, the REPL's -// transcript: it is never read from or written to the record cache. +// and its version. Kind is optional; when unknown the name determines it. A +// Transient input is a buffer no file holds, the REPL's transcript: it is never +// read from or written to the record cache. type Input struct { Name string Content []byte Version int + Kind source.Kind Transient bool } @@ -71,7 +74,7 @@ func (w *Workspace) OpenAll(inputs []Input) { return } } - docs[i] = batchDoc{doc: newDocument(in.Name, bytes.Clone(in.Content), in.Version)} + docs[i] = batchDoc{doc: newDocument(in.Name, bytes.Clone(in.Content), in.Version, in.Kind)} }) w.commitBatch(was, docs) } @@ -112,12 +115,21 @@ func (w *Workspace) cachedRecords(inputs []Input) []*libs.InterfaceRecord { return } if rec, ok := w.records.LoadInterface(keys[i]); ok && w.recordAcceptedLocked(rec) == nil { - recs[i] = rec + if rec.Kind == inputKind(inputs[i]) { + recs[i] = rec + } } }) return recs } +func inputKind(in Input) source.Kind { + if in.Kind != source.KindUnknown { + return in.Kind + } + return source.KindOf(in.Name) +} + // reserveBatch is each input's name's change count as the batch starts, which is // what commitBatch installs over: a name opened and removed meanwhile is absent // again, but its count has moved. @@ -180,7 +192,7 @@ func (w *Workspace) commitBatch(was map[string]uint64, docs []batchDoc) { parsed := make([]*Document, len(stale)) ParallelFor(w.workers, len(stale), func(i int) { held := w.docs[stale[i]] - parsed[i] = newDocument(held.Name, held.Content, held.Version) + parsed[i] = newDocument(held.Name, held.Content, held.Version, held.Kind()) }) for i, name := range stale { w.docs[name] = parsed[i] diff --git a/internal/workspace/model/batch_test.go b/internal/workspace/model/batch_test.go index fe51a2373f..dfd8d2c6e5 100644 --- a/internal/workspace/model/batch_test.go +++ b/internal/workspace/model/batch_test.go @@ -10,6 +10,7 @@ import ( "strings" "testing" + "github.com/Open-MBEE/OpenSysML/internal/syntax/ast" "github.com/Open-MBEE/OpenSysML/internal/syntax/diag" "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/workspace/libs" @@ -267,6 +268,77 @@ func TestOpenAllReplacesEarlierDocuments(t *testing.T) { } } +func TestOpenAllUsesExplicitSourceKind(t *testing.T) { + text := []byte("package P { part all; }") + ws := NewWorkspace() + ws.OpenAll([]Input{{Name: "m.json", Content: text, Kind: source.KindSysML}}) + + doc := ws.Document("m.json") + if doc == nil { + t.Fatal("m.json was not opened") + } + if doc.Kind() != source.KindSysML || ws.index.DocumentKind("m.json") != source.KindSysML { + t.Fatalf("document/index kinds = %v/%v, want SysML", doc.Kind(), ws.index.DocumentKind("m.json")) + } + if len(doc.ParseDiagnostics) != 0 { + t.Fatalf("explicit SysML input has parse diagnostics: %v", doc.ParseDiagnostics) + } + if len(doc.AST.Members) != 1 { + t.Fatalf("explicit SysML AST has %d root members, want one", len(doc.AST.Members)) + } + rootMember, ok := doc.AST.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("explicit SysML root member = %T, want membership", doc.AST.Members[0]) + } + pkg, ok := rootMember.Member.(*ast.Package) + if !ok || len(pkg.Members) != 1 { + t.Fatalf("explicit SysML AST has package members %v, want one package member", doc.AST.Members) + } + pkgMember, ok := pkg.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("explicit SysML package member = %T, want membership", pkg.Members[0]) + } + usage, ok := pkgMember.Member.(*ast.Usage) + if !ok || usage.Ident.Name != "all" || usage.IsAll { + t.Fatalf("explicit SysML part = %#v, want named `all` without the all modifier", pkg.Members[0]) + } + if syms := ws.LookupQualified("P::all"); len(syms) != 1 { + t.Fatalf("P::all = %d symbols, want 1", len(syms)) + } + + inferred := NewWorkspace() + inferred.OpenAll([]Input{{Name: "m.json", Content: text}}) + control := inferred.Document("m.json") + if control == nil { + t.Fatal("input without an explicit kind was not opened") + } + if control.Kind() != source.KindUnknown { + t.Fatalf("control document kind = %v, want unknown", control.Kind()) + } + if len(control.AST.Members) != 1 { + t.Fatalf("unknown-kind AST has %d root members, want one", len(control.AST.Members)) + } + controlRootMember, ok := control.AST.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("unknown-kind root member = %T, want membership", control.AST.Members[0]) + } + controlPkg, ok := controlRootMember.Member.(*ast.Package) + if !ok || len(controlPkg.Members) != 1 { + t.Fatalf("unknown-kind AST has package members %v, want one package member", control.AST.Members) + } + controlPkgMember, ok := controlPkg.Members[0].(*ast.Membership) + if !ok { + t.Fatalf("unknown-kind package member = %T, want membership", controlPkg.Members[0]) + } + controlUsage, ok := controlPkgMember.Member.(*ast.Usage) + if !ok || controlUsage.Ident.Name == "all" || !controlUsage.IsAll { + t.Fatalf("unknown-kind part = %#v, want an unnamed usage with the all modifier", controlPkg.Members[0]) + } + if syms := inferred.LookupQualified("P::all"); len(syms) != 0 { + t.Fatalf("P::all = %d symbols for unknown kind, want none", len(syms)) + } +} + // A document another caller changes while a batch parses keeps that change: the // batch installs only over what it reserved, so an edit, a buffer opened, a // removal and an open-then-remove made meanwhile all stand, and only the @@ -285,7 +357,7 @@ func TestOpenAllKeepsAChangeMadeWhileItParsed(t *testing.T) { was := ws.reserveBatch(inputs) docs := make([]batchDoc, len(inputs)) for i, in := range inputs { - docs[i] = batchDoc{doc: newDocument(in.Name, in.Content, in.Version)} + docs[i] = batchDoc{doc: newDocument(in.Name, in.Content, in.Version, in.Kind)} } ws.Update("a.sysml", []byte("package A { part def Edited; }"), 3) ws.Open("b.sysml", []byte("package B { part def Opened; }"), 1) diff --git a/internal/workspace/model/document.go b/internal/workspace/model/document.go index 10ae4db661..b55684eab6 100644 --- a/internal/workspace/model/document.go +++ b/internal/workspace/model/document.go @@ -28,6 +28,7 @@ type Document struct { ParseDiagnostics []parser.Diagnostic ParseWarnings []parser.Diagnostic Scope *symbols.Scope + kind source.Kind sf *source.SourceFile digest string // recorded is set for a document installed from its interface record (see @@ -58,6 +59,14 @@ func (d *Document) Recorded() bool { return d != nil && d.recorded != nil } +// Kind reports the document's source kind, inferred from its name when none is stored. +func (d *Document) Kind() source.Kind { + if d.kind != source.KindUnknown { + return d.kind + } + return source.KindOf(d.Name) +} + // TopMembers reports the document's top-level members as written, from its // tree when loaded and from its record when recorded. func (d *Document) TopMembers() []libs.TopMember { @@ -69,8 +78,8 @@ func (d *Document) TopMembers() []libs.TopMember { // newDocument parses content, which the workspace owns and never writes, and // builds the document's local scope tree. -func newDocument(name string, content []byte, version int) *Document { - sf := source.New(name, content) +func newDocument(name string, content []byte, version int, kind source.Kind) *Document { + sf := newDocumentSource(name, content, kind) p := parser.New(sf) root := p.ParseFile() scope := symbols.Build(root) @@ -83,11 +92,19 @@ func newDocument(name string, content []byte, version int) *Document { ParseDiagnostics: p.Diagnostics, ParseWarnings: p.Warnings, Scope: scope, + kind: sf.Kind(), sf: sf, digest: digestOf(content), } } +func newDocumentSource(name string, content []byte, kind source.Kind) *source.SourceFile { + if kind == source.KindUnknown { + return source.New(name, content) + } + return source.NewWithKind(name, content, kind) +} + // Digest fingerprints the document's text: equal for equal content, so a // position read from one snapshot can be checked against a later one. func (d *Document) Digest() string { diff --git a/internal/workspace/model/document_test.go b/internal/workspace/model/document_test.go index 2cd2cf77b8..761da044d8 100644 --- a/internal/workspace/model/document_test.go +++ b/internal/workspace/model/document_test.go @@ -4,10 +4,11 @@ import ( "testing" "github.com/Open-MBEE/OpenSysML/internal/syntax/ast" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" ) func TestNewDocumentParses(t *testing.T) { - d := newDocument("a.sysml", []byte("package P { namespace N; }"), 1) + d := newDocument("a.sysml", []byte("package P { namespace N; }"), 1, source.KindUnknown) if d.Name != "a.sysml" { t.Fatalf("Name = %q, want a.sysml", d.Name) } @@ -33,7 +34,7 @@ func TestNewDocumentParses(t *testing.T) { } func TestNewDocumentReportsParseDiagnostics(t *testing.T) { - d := newDocument("bad.sysml", []byte("package"), 1) + d := newDocument("bad.sysml", []byte("package"), 1, source.KindUnknown) if len(d.ParseDiagnostics) == 0 { t.Fatal("expected parse diagnostics for incomplete package") } diff --git a/internal/workspace/model/hydrate.go b/internal/workspace/model/hydrate.go index 4338a39304..ce23274590 100644 --- a/internal/workspace/model/hydrate.go +++ b/internal/workspace/model/hydrate.go @@ -6,6 +6,7 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/check/passes" "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols" + "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/workspace/libs" ) @@ -41,7 +42,7 @@ func (w *Workspace) Recorded(name string) bool { // Caller holds the write lock. func (w *Workspace) hydrateLocked(name string) *Document { held := w.docs[name] - doc := newDocument(name, held.Content, held.Version) + doc := newDocument(name, held.Content, held.Version, held.Kind()) w.docs[name] = doc w.changes[name]++ w.installLocked(doc) @@ -73,7 +74,7 @@ func (w *Workspace) hydrateAllLocked() { parsed := make([]*Document, len(recorded)) ParallelFor(w.workers, len(recorded), func(i int) { held := w.docs[recorded[i]] - parsed[i] = newDocument(held.Name, held.Content, held.Version) + parsed[i] = newDocument(held.Name, held.Content, held.Version, held.Kind()) }) for i, name := range recorded { w.docs[name] = parsed[i] @@ -129,7 +130,7 @@ func (w *Workspace) demoteLocked(name string, doc *Document) bool { if w.standIns[name] != "" { return false } - rec := w.cachedRecordLocked(name, doc.Content) + rec := w.cachedRecordLocked(name, doc.Content, doc.Kind()) if rec == nil { if _, ok := w.recordKeyLocked(name, doc.Content); !ok { return false @@ -159,7 +160,7 @@ func (w *Workspace) demoteLocked(name string, doc *Document) bool { // record's reads are answered by its own document too), else parsed. Caller // holds the write lock. func (w *Workspace) holdOnDiskLocked(name string, content []byte) { - if rec := w.acceptedRecordLocked(name, content); rec != nil { + if rec := w.acceptedRecordLocked(name, content, source.KindUnknown); rec != nil { if scope, err := symbols.BuildRecorded(rec.Scope, rec.Name); err == nil { w.installRecordedLocked(rec, scope, content, 0) w.index.ExpandWildcardImports() @@ -176,16 +177,19 @@ func (w *Workspace) holdOnDiskLocked(name string, content []byte) { // the workspace has a cache and the record answers its question; whether its // provenance holds is the caller's to check among the documents it holds it // with. Caller holds the write lock. -func (w *Workspace) acceptedRecordLocked(name string, content []byte) *libs.InterfaceRecord { +func (w *Workspace) acceptedRecordLocked(name string, content []byte, kind source.Kind) *libs.InterfaceRecord { if w.records == nil { return nil } + if kind == source.KindUnknown { + kind = source.KindOf(name) + } key, ok := w.recordKeyLocked(name, content) if !ok { return nil } rec, ok := w.records.LoadInterface(key) - if !ok || w.recordAcceptedLocked(rec) != nil { + if !ok || rec.Kind != kind || w.recordAcceptedLocked(rec) != nil { return nil } return rec @@ -194,8 +198,8 @@ func (w *Workspace) acceptedRecordLocked(name string, content []byte) *libs.Inte // cachedRecordLocked is the record cache's record of the named content, when // the workspace has a cache, the record answers its question and its // provenance holds among the documents held. Caller holds the write lock. -func (w *Workspace) cachedRecordLocked(name string, content []byte) *libs.InterfaceRecord { - rec := w.acceptedRecordLocked(name, content) +func (w *Workspace) cachedRecordLocked(name string, content []byte, kind source.Kind) *libs.InterfaceRecord { + rec := w.acceptedRecordLocked(name, content, kind) if rec == nil || !rec.Provenance.Valid(w.sourcesLocked()) { return nil } diff --git a/internal/workspace/model/library_version.go b/internal/workspace/model/library_version.go index ffbbc5fb7b..65f2df29e9 100644 --- a/internal/workspace/model/library_version.go +++ b/internal/workspace/model/library_version.go @@ -173,7 +173,7 @@ func (w *Workspace) libraryDocumentLocked(name string) *Document { if err != nil { return nil } - doc := newDocument(name, bytes.Clone(content), 0) + doc := newDocument(name, bytes.Clone(content), 0, source.KindUnknown) w.libDocs[name] = doc return doc } diff --git a/internal/workspace/model/library_version_test.go b/internal/workspace/model/library_version_test.go index 590d842141..4751557b54 100644 --- a/internal/workspace/model/library_version_test.go +++ b/internal/workspace/model/library_version_test.go @@ -560,7 +560,7 @@ func TestWorkspaceLibraryVersionEditIndexFollowsRoots(t *testing.T) { if tc.text == src { t.Fatalf("%s: the text is not declared where expected", tc.name) } - edited := newDocument("copy.kerml", []byte(tc.text), 2) + edited := newDocument("copy.kerml", []byte(tc.text), 2, source.KindUnknown) ws.mu.Lock() ei := ws.editIndexLocked("copy.kerml") idx := ei.build() @@ -599,7 +599,7 @@ func TestWorkspaceLibraryVersionEditIndexFollowsSequence(t *testing.T) { if text == src && name != "ScalarValues" { t.Fatalf("the root is not declared where expected") } - return newDocument("copy.kerml", []byte(text), 2) + return newDocument("copy.kerml", []byte(text), 2, source.KindUnknown) } ws.Open("copy.kerml", rooted("Mine").Content, 1) if got := ws.StandsInFor("copy.kerml"); got != "" { diff --git a/internal/workspace/model/record.go b/internal/workspace/model/record.go index 1ec4de8e4c..95ecd17729 100644 --- a/internal/workspace/model/record.go +++ b/internal/workspace/model/record.go @@ -10,7 +10,6 @@ import ( "github.com/Open-MBEE/OpenSysML/internal/semantic/resolve" "github.com/Open-MBEE/OpenSysML/internal/semantic/symbols" "github.com/Open-MBEE/OpenSysML/internal/syntax/diag" - "github.com/Open-MBEE/OpenSysML/internal/syntax/source" "github.com/Open-MBEE/OpenSysML/internal/workspace/libs" ) @@ -73,7 +72,7 @@ func (w *Workspace) interfaceRecordLocked(name string, doc *Document, src libs.S if !ok { return nil, fmt.Errorf("%w: %s has no analysis to record", libs.ErrUnrecordable, name) } - rec, err := libs.WriteInterface(name, source.KindOf(name), w.index, resolver, sem, gathered, diags) + rec, err := libs.WriteInterface(name, doc.Kind(), w.index, resolver, sem, gathered, diags) if err != nil { return nil, err } @@ -173,12 +172,14 @@ func (w *Workspace) recordAcceptedLocked(rec *libs.InterfaceRecord) error { // record's staleness is judged by is on. Caller holds the write lock. func (w *Workspace) installRecordedLocked(rec *libs.InterfaceRecord, scope *symbols.Scope, content []byte, version int) { w.semanticsLocked() + sf := newDocumentSource(rec.Name, content, rec.Kind) doc := &Document{ Name: rec.Name, Content: content, Version: version, Scope: scope, - sf: source.New(rec.Name, content), + kind: sf.Kind(), + sf: sf, digest: rec.Digest, recorded: &recordedDiagnostics{ diagnostics: diag.Clone(rec.Diagnostics), @@ -192,5 +193,5 @@ func (w *Workspace) installRecordedLocked(rec *libs.InterfaceRecord, scope *symb w.changes[rec.Name]++ w.displaceLocked(rec.Name) w.releaseStandInLocked(rec.Name) - w.index.AddRecordedDocument(rec.Name, rec.Kind, scope, rec.Scope.Gathered.Clone()) + w.index.AddRecordedDocument(rec.Name, doc.Kind(), scope, rec.Scope.Gathered.Clone()) } diff --git a/internal/workspace/model/workspace.go b/internal/workspace/model/workspace.go index 64687d4726..46efa6e1d9 100644 --- a/internal/workspace/model/workspace.go +++ b/internal/workspace/model/workspace.go @@ -416,7 +416,7 @@ func (w *Workspace) Remove(name string) { // reindexLocked reparses name and incrementally updates the global index. // Caller must hold the write lock. func (w *Workspace) reindexLocked(name string, content []byte, version int) { - doc := newDocument(name, content, version) + doc := newDocument(name, content, version, source.KindUnknown) w.docs[name] = doc w.changes[name]++ w.installLocked(doc) @@ -429,7 +429,7 @@ func (w *Workspace) reindexLocked(name string, content []byte, version int) { // expands wildcard imports once its documents are in. Caller holds the write lock. func (w *Workspace) installLocked(doc *Document) { w.displaceLocked(doc.Name) - w.index.AddDocumentScope(doc.Name, doc.AST, doc.Scope) // removes stale entries first + w.index.AddDocumentScopeWithKind(doc.Name, doc.AST, doc.Scope, doc.Kind()) // removes stale entries first w.standInLocked(doc.Name, doc) } @@ -610,9 +610,9 @@ func (w *Workspace) diagnosticsLocked(name string, doc *Document) []diag.Diagnos func (w *Workspace) analyze(name string, doc *Document, batch *passes.Batch) ([]diag.Diagnostic, *resolve.Reads) { parseDiags := parser.AsDiagnostics(doc.ParseDiagnostics, doc.ParseWarnings) if batch != nil { - return passes.AnalyzeInBatch(name, source.KindOf(name), doc.AST, parseDiags, w.index, w.analysis, batch) + return passes.AnalyzeInBatch(name, doc.Kind(), doc.AST, parseDiags, w.index, w.analysis, batch) } - return passes.AnalyzeShared(name, source.KindOf(name), doc.AST, parseDiags, w.analysis, w.sharedLocked()), nil + return passes.AnalyzeShared(name, doc.Kind(), doc.AST, parseDiags, w.analysis, w.sharedLocked()), nil } // LookupQualified resolves a fully-qualified name against the global index under From 9bef89440ae5753f472bf34e2d51f8dad1eba693 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 04:37:55 +0000 Subject: [PATCH 08/10] fix(export): refuse named flow ends in a flow head Co-Authored-By: jason.han --- internal/translate/export/end_forms.go | 10 ++--- .../translate/export/rdf_normative_test.go | 39 +++++++++++++++++++ 2 files changed, 44 insertions(+), 5 deletions(-) diff --git a/internal/translate/export/end_forms.go b/internal/translate/export/end_forms.go index dcfde3a00c..a6e9515075 100644 --- a/internal/translate/export/end_forms.go +++ b/internal/translate/export/end_forms.go @@ -1028,14 +1028,14 @@ func (d *decoder) flowEndSegments(end rdf.Term, in *element) ([]rdf.Term, error) refuse := func(note string) ([]rdf.Term, error) { return nil, &UnsupportedError{What: fmt.Sprintf("the flow end <%s> of <%s>", end.Value, in.iri), Note: note} } + if d.graph.HasProperty(end, rdf.SysML+pDeclaredName) || + d.graph.HasProperty(end, rdf.SysML+pDeclaredShortName) || + len(d.graph.Objects(end, rdf.SysML+pOwnedAnnotation)) > 0 { + return refuse("it declares a name or annotations that the `from`/`to` form cannot carry") + } toolkitFeatures := d.toolkitFlowFeatures(end) toolkitShape := len(toolkitFeatures) > 0 if toolkitShape { - if d.graph.HasProperty(end, rdf.SysML+pDeclaredName) || - d.graph.HasProperty(end, rdf.SysML+pDeclaredShortName) || - len(d.graph.Objects(end, rdf.SysML+pOwnedAnnotation)) > 0 { - return refuse("it declares a name or annotations that the `from`/`to` form cannot carry") - } if len(toolkitFeatures) != 1 { return refuse(fmt.Sprintf("it owns %d toolkit FlowFeatures, and a flow end writes exactly one reference chain", len(toolkitFeatures))) } diff --git a/internal/translate/export/rdf_normative_test.go b/internal/translate/export/rdf_normative_test.go index 20f3114b38..03d77df15d 100644 --- a/internal/translate/export/rdf_normative_test.go +++ b/internal/translate/export/rdf_normative_test.go @@ -842,3 +842,42 @@ func TestFlowEndsRoundTripFromFeatureChains(t *testing.T) { t.Fatalf("the decoded flow does not parse: %v\n%s", p.Diagnostics, notation) } } + +func TestFlowEndNamesAreRefusedInFlowHeads(t *testing.T) { + const model = `package P { + part def Vessel { + part x; + part y; + } + part def Host { + part a : Vessel; + part b : Vessel; + flow from a.x to b.y; + } +}` + for _, property := range []string{pDeclaredName, pDeclaredShortName} { + t.Run(property, func(t *testing.T) { + graph := normativeGraph(t, model) + var end rdf.Term + for _, triple := range graph.Triples() { + if triple.Predicate == rdf.IRI(rdf.RDFType) && triple.Object == rdf.SysMLTerm(mFlowEnd) { + end = triple.Subject + break + } + } + if end.Value == "" { + t.Fatal("flow has no FlowEnd") + } + graph.Add(end, rdf.SysMLTerm(property), rdf.String("outlet")) + + _, err := ToSysML(graph) + var unsupported *UnsupportedError + if !errors.As(err, &unsupported) { + t.Fatalf("ToSysML error = %v, want UnsupportedError", err) + } + if !strings.Contains(err.Error(), end.Value) { + t.Fatalf("error %q does not name flow end %s", err, end.Value) + } + }) + } +} From a260ca069c862255ef2e530ef0e9b25f963a7ba1 Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 05:03:49 +0000 Subject: [PATCH 09/10] fix(workspace): keep a document's source kind across updates Co-Authored-By: jason.han --- internal/workspace/model/batch_test.go | 58 ++++++++++++++++++++++++++ internal/workspace/model/hydrate.go | 6 ++- internal/workspace/model/workspace.go | 6 ++- 3 files changed, 68 insertions(+), 2 deletions(-) diff --git a/internal/workspace/model/batch_test.go b/internal/workspace/model/batch_test.go index dfd8d2c6e5..30436f1ce5 100644 --- a/internal/workspace/model/batch_test.go +++ b/internal/workspace/model/batch_test.go @@ -339,6 +339,64 @@ func TestOpenAllUsesExplicitSourceKind(t *testing.T) { } } +func TestOpenAllPreservesExplicitSourceKindAcrossUpdate(t *testing.T) { + text := []byte("package P { part all; }") + ws := NewWorkspace() + ws.OpenAll([]Input{{Name: "m.json", Content: text, Kind: source.KindSysML}}) + + ws.Update("m.json", text, 2) + + doc := ws.Document("m.json") + if doc == nil { + t.Fatal("m.json was not opened") + } + if doc.Kind() != source.KindSysML { + t.Fatalf("document kind = %v, want SysML", doc.Kind()) + } + if doc.Version != 2 { + t.Fatalf("document version = %d, want 2", doc.Version) + } + if syms := ws.LookupQualified("P::all"); len(syms) != 1 { + t.Fatalf("P::all = %d symbols after update, want 1", len(syms)) + } +} + +func TestSetOnDiskPreservesHeldExplicitSourceKind(t *testing.T) { + initial := []byte("package P { part all; }") + updated := []byte("package P { part all; part def B; }") + ws := NewWorkspace() + ws.OpenAll([]Input{{Name: "m.json", Content: initial, Kind: source.KindSysML}}) + ws.SetOnDisk("m.json", initial) + ws.Close("m.json") + + doc := ws.Document("m.json") + if doc == nil || doc.Kind() != source.KindSysML { + if doc == nil { + t.Fatal("m.json was not held after closing") + } + t.Fatalf("document kind after close = %v, want SysML", doc.Kind()) + } + if syms := ws.LookupQualified("P::all"); len(syms) != 1 { + t.Fatalf("P::all = %d symbols after close, want 1", len(syms)) + } + + ws.SetOnDisk("m.json", updated) + + doc = ws.Document("m.json") + if doc == nil || doc.Kind() != source.KindSysML { + if doc == nil { + t.Fatal("m.json was not held after disk update") + } + t.Fatalf("document kind after disk update = %v, want SysML", doc.Kind()) + } + if syms := ws.LookupQualified("P::all"); len(syms) != 1 { + t.Fatalf("P::all = %d symbols after disk update, want 1", len(syms)) + } + if syms := ws.LookupQualified("P::B"); len(syms) != 1 { + t.Fatalf("P::B = %d symbols after disk update, want 1", len(syms)) + } +} + // A document another caller changes while a batch parses keeps that change: the // batch installs only over what it reserved, so an edit, a buffer opened, a // removal and an open-then-remove made meanwhile all stand, and only the diff --git a/internal/workspace/model/hydrate.go b/internal/workspace/model/hydrate.go index ce23274590..29e81364d4 100644 --- a/internal/workspace/model/hydrate.go +++ b/internal/workspace/model/hydrate.go @@ -160,7 +160,11 @@ func (w *Workspace) demoteLocked(name string, doc *Document) bool { // record's reads are answered by its own document too), else parsed. Caller // holds the write lock. func (w *Workspace) holdOnDiskLocked(name string, content []byte) { - if rec := w.acceptedRecordLocked(name, content, source.KindUnknown); rec != nil { + kind := source.KindUnknown + if held := w.docs[name]; held != nil { + kind = held.Kind() + } + if rec := w.acceptedRecordLocked(name, content, kind); rec != nil { if scope, err := symbols.BuildRecorded(rec.Scope, rec.Name); err == nil { w.installRecordedLocked(rec, scope, content, 0) w.index.ExpandWildcardImports() diff --git a/internal/workspace/model/workspace.go b/internal/workspace/model/workspace.go index 46efa6e1d9..1a4d9936e3 100644 --- a/internal/workspace/model/workspace.go +++ b/internal/workspace/model/workspace.go @@ -416,7 +416,11 @@ func (w *Workspace) Remove(name string) { // reindexLocked reparses name and incrementally updates the global index. // Caller must hold the write lock. func (w *Workspace) reindexLocked(name string, content []byte, version int) { - doc := newDocument(name, content, version, source.KindUnknown) + kind := source.KindUnknown + if held := w.docs[name]; held != nil { + kind = held.Kind() + } + doc := newDocument(name, content, version, kind) w.docs[name] = doc w.changes[name]++ w.installLocked(doc) From afaf8450a5bf6e3076b4f14f0c6aa1b712ece69a Mon Sep 17 00:00:00 2001 From: Devin AI <158243242+devin-ai-integration[bot]@users.noreply.github.com> Date: Sun, 4 Oct 2026 06:30:23 +0000 Subject: [PATCH 10/10] fix(export): preserve kindless API JSON returns Co-Authored-By: jason.han --- .../translate/export/api_json_import_test.go | 61 +++++++++++++++++++ internal/translate/export/rdf_in_toolkit.go | 5 +- 2 files changed, 64 insertions(+), 2 deletions(-) diff --git a/internal/translate/export/api_json_import_test.go b/internal/translate/export/api_json_import_test.go index 1e6f642d3d..d2bf20a334 100644 --- a/internal/translate/export/api_json_import_test.go +++ b/internal/translate/export/api_json_import_test.go @@ -261,6 +261,67 @@ func TestReturnUsageKeepsItsMetaclass(t *testing.T) { } } +func TestAPIJSONReferenceResultOmitsKindKeyword(t *testing.T) { + file := source.New("return.sysml", []byte("package R { calc def F { return result : Real; } }")) + p := parser.New(file) + root := p.ParseFile() + if len(p.Diagnostics) != 0 { + t.Fatalf("the fixture does not parse: %v", p.Diagnostics) + } + graph, err := ToRDF(file, root) + if err != nil { + t.Fatalf("ToRDF: %v", err) + } + data, err := WriteAPIJSON(graph) + if err != nil { + t.Fatalf("WriteAPIJSON: %v", err) + } + var elements []map[string]any + if err := json.Unmarshal(data, &elements); err != nil { + t.Fatalf("decode API JSON: %v", err) + } + found := false + foundReturnMembership := false + for _, element := range elements { + if element["@type"] == "ReferenceUsage" && element["declaredName"] == "result" { + found = true + if _, ok := element["declaredKeyword"]; ok { + t.Fatal("API JSON unexpectedly retains the declared kind keyword") + } + } + if element["@type"] == mReturnParameterMembership { + foundReturnMembership = true + } + } + if !found { + t.Fatal("API JSON has no ReferenceUsage result") + } + if !foundReturnMembership { + t.Fatal("API JSON has no ReturnParameterMembership") + } + out, err := APIJSONToSysML(data, nil) + if err != nil { + t.Fatalf("APIJSONToSysML: %v", err) + } + if !bytes.Contains(out, []byte("return result : Real")) || + bytes.Contains(out, []byte("return attribute")) { + t.Fatalf("API JSON ReferenceUsage result was written with a kind keyword:\n%s", out) + } + roundTrip := source.New("return.sysml", out) + roundParser := parser.New(roundTrip) + roundRoot := roundParser.ParseFile() + if len(roundParser.Diagnostics) != 0 { + t.Fatalf("the decoded notation does not parse: %v\n%s", roundParser.Diagnostics, out) + } + reparsed, err := ToRDF(roundTrip, roundRoot) + if err != nil { + t.Fatalf("round-trip ToRDF: %v", err) + } + if got := resultUsageTypes(t, reparsed); !reflect.DeepEqual(got, map[string]int{"ReferenceUsage": 1}) { + t.Fatalf("API JSON return metaclasses = %v, want ReferenceUsage", got) + } +} + func graphWithoutSourceText(graph *rdf.Graph) map[rdf.Triple]bool { out := make(map[rdf.Triple]bool, graph.Len()) for _, triple := range graph.Triples() { diff --git a/internal/translate/export/rdf_in_toolkit.go b/internal/translate/export/rdf_in_toolkit.go index 7cc9261c18..a6e110fc29 100644 --- a/internal/translate/export/rdf_in_toolkit.go +++ b/internal/translate/export/rdf_in_toolkit.go @@ -1171,7 +1171,7 @@ func (n *normalizer) statePerformedKeyword(subject, ms rdf.Term, m string) { // markImplicitKinds flags the toolkit ReferenceUsages that print no keyword: // ReferenceUsage is the kindless member metaclass — `ref` states the kind when // the keyword is written, and the compact form records no keyword for it. A -// parameter whose membership spells its keyword — a satisfy's `subject` — keeps it. +// return membership states `return`, not a usage kind. func (n *normalizer) markImplicitKinds() { graph, meta := n.graph, n.meta for _, subject := range graph.Subjects() { @@ -1179,7 +1179,8 @@ func (n *normalizer) markImplicitKinds() { continue } membership := firstIRI(graph, subject, pOwningMembership, pOwningRelationship) - if mm := meta(membership); mm != "" && mm != "FeatureMembership" && mm != "OwningMembership" { + if mm := meta(membership); mm != "" && mm != "FeatureMembership" && + mm != "OwningMembership" && mm != mReturnParameterMembership { continue } if !graph.HasProperty(subject, rdf.OpenSysML+xDeclaredKeyword) {