| /******************************************************************************* |
| * Copyright (c) 2010, 2022 Willink Transformations and others. |
| * All rights reserved. This program and the accompanying materials |
| * are made available under the terms of the Eclipse Public License v2.0 |
| * which accompanies this distribution, and is available at |
| * http://www.eclipse.org/legal/epl-v20.html |
| * |
| * Contributors: |
| * E.D.Willink - initial API and implementation |
| ******************************************************************************* |
| * This code is 100% auto-generated |
| * from: /org.eclipse.qvtd.runtime/model/QVTruntimeLibrary.oclstdlib |
| * by: org.eclipse.ocl.examples.build.xtend.generateOCLstdlib.xtend |
| * and: org.eclipse.ocl.examples.build.GenerateOCLstdlibModel.mwe2 |
| * |
| * Do not edit it. |
| *******************************************************************************/ |
| package org.eclipse.qvtd.runtime.model; |
| |
| import java.io.IOException; |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| import org.eclipse.emf.common.notify.Notification; |
| import org.eclipse.emf.common.notify.NotificationChain; |
| import org.eclipse.emf.common.util.TreeIterator; |
| import org.eclipse.emf.common.util.URI; |
| import org.eclipse.emf.ecore.EObject; |
| import org.eclipse.emf.ecore.EPackage; |
| import org.eclipse.emf.ecore.EReference; |
| import org.eclipse.emf.ecore.impl.BasicEObjectImpl; |
| import org.eclipse.emf.ecore.resource.Resource; |
| import org.eclipse.emf.ecore.resource.ResourceSet; |
| import org.eclipse.emf.ecore.xmi.impl.XMIResourceImpl; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.*; |
| import org.eclipse.ocl.pivot.Class; |
| import org.eclipse.ocl.pivot.Package; |
| import org.eclipse.ocl.pivot.ids.IdManager; |
| import org.eclipse.ocl.pivot.ids.PackageId; |
| import org.eclipse.ocl.pivot.internal.library.StandardLibraryContribution; |
| import org.eclipse.ocl.pivot.internal.resource.ASResourceImpl; |
| import org.eclipse.ocl.pivot.internal.resource.OCLASResourceFactory; |
| import org.eclipse.ocl.pivot.internal.utilities.AbstractContents; |
| import org.eclipse.ocl.pivot.internal.utilities.PivotUtilInternal; |
| import org.eclipse.ocl.pivot.model.OCLmetamodel; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.MetamodelManager; |
| import org.eclipse.ocl.pivot.utilities.PivotConstants; |
| import org.eclipse.ocl.pivot.utilities.PivotUtil; |
| |
| import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibPackage; |
| import org.eclipse.ocl.pivot.oclstdlib.OCLstdlibPackage; |
| import org.eclipse.ocl.pivot.PivotPackage; |
| import org.eclipse.qvtd.runtime.qvtruntimelibrary.QVTruntimeLibraryPackage; |
| |
| /** |
| * This is the http://www.eclipse.org/qvt/2019/QVTruntimeLibrary Standard Library |
| * auto-generated from /org.eclipse.qvtd.runtime/model/QVTruntimeLibrary.oclstdlib. |
| * It facilitates efficient library loading without the overheads of model reading. |
| * <p> |
| * This Standard Library may be registered as the definition of a Standard Library for |
| * the OCL evaluation framework by invoking {@link #install}. |
| * <p> |
| * The Standard Library is normally activated when the MetamodelManager attempts |
| * to locate a library type when its default Standard Library URI is the same |
| * as this Standard Library. |
| */ |
| @SuppressWarnings("unused") |
| public class QVTruntimeLibrary extends ASResourceImpl |
| { |
| /** |
| * The static package-of-types pivot model of the Standard Library. |
| */ |
| private static QVTruntimeLibrary INSTANCE = null; |
| |
| /** |
| * The URI of this Standard Library. |
| */ |
| public static final @NonNull String STDLIB_URI = "http://www.eclipse.org/qvt/2019/QVTruntimeLibrary"; |
| |
| /** |
| * The URI of the AS representation of this Standard Library. |
| */ |
| public static final @NonNull URI STDLIB_AS_URI = URI.createURI("http://www.eclipse.org/qvt/2019/QVTruntimeLibrary" + PivotConstants.DOT_OCL_AS_FILE_EXTENSION); |
| |
| /** |
| * Return the default http://www.eclipse.org/qvt/2019/QVTruntimeLibrary standard Library Resource |
| * if it jas been created, or null if not. |
| * This static definition auto-generated from /org.eclipse.qvtd.runtime/model/QVTruntimeLibrary.oclstdlib |
| * is used as the default when no overriding copy is registered. |
| * It cannot be unloaded or rather unloading has no effect. |
| */ |
| public static @Nullable QVTruntimeLibrary basicGetDefault() { |
| return INSTANCE; |
| } |
| |
| /** |
| * Return the default http://www.eclipse.org/qvt/2019/QVTruntimeLibrary standard Library Resource. |
| * This static definition auto-generated from /org.eclipse.qvtd.runtime/model/QVTruntimeLibrary.oclstdlib |
| * is used as the default when no overriding copy is registered. |
| * It cannot be unloaded or rather unloading has no effect. |
| */ |
| public static @NonNull QVTruntimeLibrary getDefault() { |
| QVTruntimeLibrary oclstdlib = INSTANCE; |
| if (oclstdlib == null) { |
| Contents contents = new Contents("http://www.eclipse.org/qvt/2019/QVTruntimeLibrary"); |
| String asURI = STDLIB_URI + PivotConstants.DOT_OCL_AS_FILE_EXTENSION; |
| oclstdlib = INSTANCE = new ReadOnly(asURI, contents.getModel()); |
| oclstdlib.setSaveable(false); |
| } |
| return oclstdlib; |
| } |
| |
| /** |
| * Return the default http://www.eclipse.org/qvt/2019/QVTruntimeLibrary standard Library model. |
| * This static definition auto-generated from /org.eclipse.qvtd.runtime/model/QVTruntimeLibrary.oclstdlib |
| * is used as the default when no overriding copy is registered. |
| */ |
| public static @NonNull Model getDefaultModel() { |
| Model model = (Model)(getDefault().getContents().get(0)); |
| assert model != null; |
| return model; |
| } |
| |
| /** |
| * Install this library in the {@link StandardLibraryContribution#REGISTRY} |
| * and the {@link OCLASResourceFactory#REGISTRY}. |
| * This method may be invoked by standalone applications to replicate |
| * the registration that should appear as a standard_library plugin |
| * extension when running within Eclipse. |
| */ |
| public static void install() { |
| EPackage.Registry.INSTANCE.put(OCLstdlibPackage.eNS_URI, OCLstdlibPackage.eINSTANCE); |
| Loader contribution = new Loader(); |
| StandardLibraryContribution.REGISTRY.put(STDLIB_URI, contribution); |
| OCLASResourceFactory.REGISTRY.put(STDLIB_AS_URI, contribution); |
| } |
| |
| /** |
| * Install this library in the {@link StandardLibraryContribution#REGISTRY} |
| * and the {@link OCLASResourceFactory#REGISTRY} |
| * unless some other library contribution has already been installed. |
| */ |
| public static void lazyInstall() { |
| if (StandardLibraryContribution.REGISTRY.get(STDLIB_URI) == null) { |
| install(); |
| } |
| } |
| |
| /** |
| * Uninstall this library from the {@link StandardLibraryContribution#REGISTRY} |
| * and the {@link OCLASResourceFactory#REGISTRY}. |
| * This method may be invoked by standalone applications to release the library |
| * resources for garbage collection and memory leakage detection. |
| */ |
| public static void uninstall() { |
| StandardLibraryContribution.REGISTRY.remove(STDLIB_URI); |
| OCLASResourceFactory.REGISTRY.remove(STDLIB_AS_URI); |
| INSTANCE = null; |
| } |
| |
| /** |
| * The Loader shares the Standard Library instance whenever this default library |
| * is loaded from the registry of Standard Libraries populated by the standard_library |
| * extension point. |
| */ |
| public static class Loader implements StandardLibraryContribution |
| { |
| @Override |
| public @NonNull StandardLibraryContribution getContribution() { |
| return this; |
| } |
| |
| @Override |
| public @NonNull Resource getResource() { |
| return getDefault(); |
| } |
| } |
| |
| /** |
| * A ReadOnly QVTruntimeLibrary overrides inherited functionality to impose immutable shared behaviour. |
| */ |
| protected static class ReadOnly extends QVTruntimeLibrary implements ImmutableResource |
| { |
| protected ReadOnly(@NonNull String asURI, @NonNull Model libraryModel) { |
| super(asURI, libraryModel); |
| } |
| |
| /** |
| * Overridden to inhibit entry of the shared instance in any ResourceSet. |
| */ |
| @Override |
| public NotificationChain basicSetResourceSet(ResourceSet resourceSet, NotificationChain notifications) { |
| return notifications; |
| } |
| |
| /** |
| * Overridden to inhibit unloading of the shared instance. |
| */ |
| @Override |
| protected void doUnload() {} |
| |
| @Override |
| public boolean isCompatibleWith(@NonNull String metamodelURI) { |
| return OCLmetamodel.PIVOT_URI.equals(metamodelURI); |
| } |
| |
| /** |
| * Overridden to trivialise loading of the shared instance. |
| */ |
| @Override |
| public void load(Map<?, ?> options) throws IOException { |
| if (this != INSTANCE) { |
| super.load(options); |
| } |
| else { |
| setLoaded(true); |
| } |
| } |
| |
| /** |
| * Overridden to inhibit unloading of the shared instance. |
| */ |
| @Override |
| protected Notification setLoaded(boolean isLoaded) { |
| if (isLoaded) { |
| return super.setLoaded(isLoaded); |
| } |
| else { |
| return null; |
| } |
| } |
| } |
| |
| /** |
| * Construct a copy of the OCL Standard Library with specified resource URI, |
| * and package name, prefix and namespace URI. |
| */ |
| public static @NonNull QVTruntimeLibrary create(@NonNull String asURI) { |
| Contents contents = new Contents(asURI); |
| return new QVTruntimeLibrary(asURI, contents.getModel()); |
| } |
| |
| /** |
| * Construct an OCL Standard Library with specified resource URI and library content. |
| */ |
| private QVTruntimeLibrary(@NonNull String asURI, @NonNull Model libraryModel) { |
| super(ClassUtil.nonNullState(URI.createURI(asURI)), OCLASResourceFactory.getInstance()); |
| assert PivotUtilInternal.isASURI(asURI); |
| getContents().add(libraryModel); |
| } |
| |
| private static class Contents extends AbstractContents |
| { |
| private final @NonNull Model model; |
| private final @NonNull Package ocl; |
| private final @NonNull Library qvtruntimelibrary; |
| private final @NonNull Package orphanage; |
| |
| private Contents(@NonNull String asURI) |
| { |
| model = createModel(asURI); |
| ocl = createPackage("ocl", "ocl", "http://www.eclipse.org/ocl/2015/Library", IdManager.METAMODEL, OCLstdlibPackage.eINSTANCE); |
| qvtruntimelibrary = createLibrary("qvtruntimelibrary", "qvtrtlib", "http://www.eclipse.org/qvt/2019/QVTruntimeLibrary", null, QVTruntimeLibraryPackage.eINSTANCE); |
| orphanage = createPackage("$$", "orphanage", "http://www.eclipse.org/ocl/2015/Orphanage", null, null); |
| installPackages(); |
| installClassTypes(); |
| installCollectionTypes(); |
| installOperations(); |
| installProperties(); |
| installTemplateBindings(); |
| installComments(); |
| } |
| |
| public @NonNull Model getModel() { |
| return model; |
| } |
| |
| private final @NonNull Package _ocl = getPackage(org.eclipse.ocl.pivot.model.OCLstdlib.getDefaultModel(), "ocl"); |
| private final @NonNull Package _pivot = getPackage(org.eclipse.ocl.pivot.model.OCLmetamodel.getDefaultModel(), "pivot"); |
| private final @NonNull CollectionType _Collection = getCollectionType(_ocl, "Collection"); |
| private final @NonNull Class _CollectionItem = getClass(_pivot, "CollectionItem"); |
| private final @NonNull Class _CollectionLiteralExp = getClass(_pivot, "CollectionLiteralExp"); |
| private final @NonNull Class _CollectionRange = getClass(_pivot, "CollectionRange"); |
| private final @NonNull Class _Element = getClass(_pivot, "Element"); |
| private final @NonNull Class _MapLiteralExp = getClass(_pivot, "MapLiteralExp"); |
| private final @NonNull Class _MapLiteralPart = getClass(_pivot, "MapLiteralPart"); |
| private final @NonNull Class _OCLExpression = getClass(_pivot, "OCLExpression"); |
| private final @NonNull AnyType _OclAny = getAnyType(_ocl, "OclAny"); |
| private final @NonNull Class _OclElement = getClass(_ocl, "OclElement"); |
| private final @NonNull VoidType _OclVoid = getVoidType(_ocl, "OclVoid"); |
| private final @NonNull CollectionType _OrderedCollection = getCollectionType(_ocl, "OrderedCollection"); |
| private final @NonNull OrderedSetType _OrderedSet = getOrderedSetType(_ocl, "OrderedSet"); |
| private final @NonNull Class _Property = getClass(_pivot, "Property"); |
| private final @NonNull SetType _Set = getSetType(_ocl, "Set"); |
| private final @NonNull Class _ShadowExp = getClass(_pivot, "ShadowExp"); |
| private final @NonNull Class _TupleLiteralExp = getClass(_pivot, "TupleLiteralExp"); |
| private final @NonNull Class _TupleLiteralPart = getClass(_pivot, "TupleLiteralPart"); |
| private final @NonNull Class _TypeExp = getClass(_pivot, "TypeExp"); |
| private final @NonNull CollectionType _UniqueCollection = getCollectionType(_ocl, "UniqueCollection"); |
| private final @NonNull TemplateParameter _Collection_T = getTemplateParameter(_Collection, 0); |
| private final @NonNull TemplateParameter _OrderedCollection_T = getTemplateParameter(_OrderedCollection, 0); |
| private final @NonNull TemplateParameter _OrderedSet_T = getTemplateParameter(_OrderedSet, 0); |
| private final @NonNull TemplateParameter _Set_T = getTemplateParameter(_Set, 0); |
| private final @NonNull TemplateParameter _UniqueCollection_T = getTemplateParameter(_UniqueCollection, 0); |
| |
| private void installPackages() { |
| model.getOwnedPackages().add(ocl); |
| model.getOwnedPackages().add(qvtruntimelibrary); |
| model.getOwnedPackages().add(orphanage); |
| model.getOwnedImports().add(createImport(null, _ocl)); |
| model.getOwnedImports().add(createImport("ocl", _pivot)); |
| } |
| |
| private final @NonNull Class _OclElement_1 = createClass("OclElement"); |
| |
| private final @NonNull Class _Extent = createClass(QVTruntimeLibraryPackage.Literals.EXTENT); |
| private final @NonNull Class _Model = createClass(QVTruntimeLibraryPackage.Literals.MODEL); |
| private final @NonNull Class _PseudoOperations = createClass("PseudoOperations"); |
| private final @NonNull Class _Transformation = createClass(QVTruntimeLibraryPackage.Literals.TRANSFORMATION); |
| |
| private final @NonNull TemplateParameter tp_PseudoOperations_collection_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_error_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_if_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_loop_E = createTemplateParameter("E"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_mapPart_K = createTemplateParameter("K"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_mapPart_V = createTemplateParameter("V"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_map_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_range_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_shadow_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_tuple_T = createTemplateParameter("T"); |
| private final @NonNull TemplateParameter tp_PseudoOperations_type_V = createTemplateParameter("V"); |
| |
| private final @NonNull CollectionType _Collection_OclElement = createCollectionType(_Collection); |
| private final @NonNull CollectionType _Collection_CollectionItem = createCollectionType(_Collection); |
| private final @NonNull CollectionType _Collection_Element = createCollectionType(_Collection); |
| private final @NonNull CollectionType _Collection_Property = createCollectionType(_Collection); |
| private final @NonNull CollectionType _Collection_TupleLiteralPart = createCollectionType(_Collection); |
| private final @NonNull CollectionType _Collection_PseudoOperations_loop_E = createCollectionType(_Collection); |
| private final @NonNull CollectionType _OrderedCollection_OclElement = createCollectionType(_OrderedCollection); |
| private final @NonNull OrderedSetType _OrderedSet_OclElement_NullFree = createOrderedSetType(_OrderedSet); |
| private final @NonNull SetType _Set_CollectionItem = createSetType(_Set); |
| private final @NonNull SetType _Set_Element = createSetType(_Set); |
| private final @NonNull SetType _Set_Property = createSetType(_Set); |
| private final @NonNull SetType _Set_TupleLiteralPart = createSetType(_Set); |
| private final @NonNull SetType _Set_PseudoOperations_loop_E = createSetType(_Set); |
| private final @NonNull CollectionType _UniqueCollection_OclElement = createCollectionType(_UniqueCollection); |
| private final @NonNull CollectionType _UniqueCollection_CollectionItem = createCollectionType(_UniqueCollection); |
| private final @NonNull CollectionType _UniqueCollection_Element = createCollectionType(_UniqueCollection); |
| private final @NonNull CollectionType _UniqueCollection_Property = createCollectionType(_UniqueCollection); |
| private final @NonNull CollectionType _UniqueCollection_TupleLiteralPart = createCollectionType(_UniqueCollection); |
| private final @NonNull CollectionType _UniqueCollection_PseudoOperations_loop_E = createCollectionType(_UniqueCollection); |
| |
| private void installClassTypes() { |
| List<Class> ownedClasses; |
| List<Class> superClasses; |
| Class type; |
| |
| ownedClasses = ocl.getOwnedClasses(); |
| ownedClasses.add(type = _OclElement_1); |
| |
| ownedClasses = qvtruntimelibrary.getOwnedClasses(); |
| ownedClasses.add(type = _Extent); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Model); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _PseudoOperations); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Transformation); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| } |
| |
| private void installCollectionTypes() { |
| List<Class> ownedClasses; |
| List<Class> superClasses; |
| CollectionType type; |
| |
| ownedClasses = orphanage.getOwnedClasses(); |
| ownedClasses.add(type = _Collection_OclElement); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Collection_CollectionItem); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Collection_Element); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Collection_Property); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Collection_TupleLiteralPart); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _Collection_PseudoOperations_loop_E); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OclElement); |
| ownedClasses.add(type = _OrderedCollection_OclElement); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_OclElement); |
| ownedClasses.add(type = _OrderedSet_OclElement_NullFree); |
| type.setIsNullFree(true); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_OrderedCollection_OclElement); |
| superClasses.add(_UniqueCollection_OclElement); |
| ownedClasses.add(type = _Set_CollectionItem); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_UniqueCollection_CollectionItem); |
| ownedClasses.add(type = _Set_Element); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_UniqueCollection_Element); |
| ownedClasses.add(type = _Set_Property); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_UniqueCollection_Property); |
| ownedClasses.add(type = _Set_TupleLiteralPart); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_UniqueCollection_TupleLiteralPart); |
| ownedClasses.add(type = _Set_PseudoOperations_loop_E); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_UniqueCollection_PseudoOperations_loop_E); |
| ownedClasses.add(type = _UniqueCollection_OclElement); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_OclElement); |
| ownedClasses.add(type = _UniqueCollection_CollectionItem); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_CollectionItem); |
| ownedClasses.add(type = _UniqueCollection_Element); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_Element); |
| ownedClasses.add(type = _UniqueCollection_Property); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_Property); |
| ownedClasses.add(type = _UniqueCollection_TupleLiteralPart); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_TupleLiteralPart); |
| ownedClasses.add(type = _UniqueCollection_PseudoOperations_loop_E); |
| superClasses = type.getSuperClasses(); |
| superClasses.add(_Collection_PseudoOperations_loop_E); |
| } |
| |
| private final @NonNull Operation op_PseudoOperations_collection = createOperation("collection", _CollectionLiteralExp, null, null, tp_PseudoOperations_collection_T); |
| private final @NonNull Operation op_PseudoOperations_error = createOperation("error", _OclVoid, null, null, tp_PseudoOperations_error_T); |
| private final @NonNull Operation op_PseudoOperations_if = createOperation("if", tp_PseudoOperations_if_T, null, null, tp_PseudoOperations_if_T); |
| private final @NonNull Operation op_PseudoOperations_loop = createOperation("loop", _OclAny, null, null, tp_PseudoOperations_loop_E); |
| private final @NonNull Operation op_PseudoOperations_mapPart = createOperation("mapPart", _MapLiteralPart, null, null, tp_PseudoOperations_mapPart_K, tp_PseudoOperations_mapPart_V); |
| private final @NonNull Operation op_PseudoOperations_map = createOperation("map", _MapLiteralExp, null, null, tp_PseudoOperations_map_T); |
| private final @NonNull Operation op_PseudoOperations_range = createOperation("range", _CollectionRange, null, null, tp_PseudoOperations_range_T); |
| private final @NonNull Operation op_PseudoOperations_shadow = createOperation("shadow", _ShadowExp, null, null, tp_PseudoOperations_shadow_T); |
| private final @NonNull Operation op_PseudoOperations_tuple = createOperation("tuple", _TupleLiteralExp, null, null, tp_PseudoOperations_tuple_T); |
| private final @NonNull Operation op_PseudoOperations_type = createOperation("type", _TypeExp, null, null, tp_PseudoOperations_type_V); |
| |
| private void installOperations() { |
| List<Operation> ownedOperations; |
| List<Parameter> ownedParameters; |
| Operation operation; |
| Parameter parameter; |
| |
| ownedOperations = _PseudoOperations.getOwnedOperations(); |
| ownedOperations.add(operation = op_PseudoOperations_collection); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("items", _Set_CollectionItem, true)); |
| ownedOperations.add(operation = op_PseudoOperations_error); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("elements", _Set_Element, true)); |
| ownedOperations.add(operation = op_PseudoOperations_if); |
| operation.setIsRequired(false); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("condition", tp_PseudoOperations_if_T, false)); |
| ownedParameters.add(parameter = createParameter("then", tp_PseudoOperations_if_T, false)); |
| ownedParameters.add(parameter = createParameter("else", tp_PseudoOperations_if_T, false)); |
| ownedOperations.add(operation = op_PseudoOperations_loop); |
| operation.setIsRequired(false); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("source", _OCLExpression, true)); |
| ownedParameters.add(parameter = createParameter("iterators", _Set_PseudoOperations_loop_E, true)); |
| ownedParameters.add(parameter = createParameter("body", _OCLExpression, true)); |
| ownedOperations.add(operation = op_PseudoOperations_mapPart); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("key", tp_PseudoOperations_mapPart_K, false)); |
| ownedParameters.add(parameter = createParameter("value", tp_PseudoOperations_mapPart_V, false)); |
| ownedOperations.add(operation = op_PseudoOperations_map); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("parts", _Set_Property, true)); |
| ownedOperations.add(operation = op_PseudoOperations_range); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("first", tp_PseudoOperations_range_T, false)); |
| ownedParameters.add(parameter = createParameter("last", tp_PseudoOperations_range_T, false)); |
| ownedOperations.add(operation = op_PseudoOperations_shadow); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("parts", _Set_Property, true)); |
| ownedOperations.add(operation = op_PseudoOperations_tuple); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("parts", _Set_TupleLiteralPart, true)); |
| ownedOperations.add(operation = op_PseudoOperations_type); |
| operation.setIsStatic(true); |
| ownedParameters = operation.getOwnedParameters(); |
| ownedParameters.add(parameter = createParameter("type", tp_PseudoOperations_type_V, false)); |
| } |
| |
| |
| private final @NonNull Property pr_OclElement_extent_elements = createProperty("extent", _Extent); |
| |
| private final @NonNull Property pr_Extent_elements = createProperty("elements", _OrderedSet_OclElement_NullFree); |
| |
| private void installProperties() { |
| List<Property> ownedProperties; |
| Property property; |
| |
| ownedProperties = _OclElement_1.getOwnedProperties(); |
| ownedProperties.add(property = pr_OclElement_extent_elements); |
| property.setIsImplicit(true); |
| property.setIsRequired(false); |
| property.setIsResolveProxies(true); |
| property.setOpposite(pr_Extent_elements); |
| |
| ownedProperties = _Extent.getOwnedProperties(); |
| ownedProperties.add(property = pr_Extent_elements); |
| property.setIsResolveProxies(true); |
| property.setOpposite(pr_OclElement_extent_elements); |
| } |
| |
| private void installTemplateBindings() { |
| addBinding(_Collection_CollectionItem, _CollectionItem); |
| addBinding(_Collection_Element, _Element); |
| addBinding(_Collection_OclElement, _OclElement); |
| addBinding(_Collection_Property, _Property); |
| addBinding(_Collection_PseudoOperations_loop_E, tp_PseudoOperations_loop_E); |
| addBinding(_Collection_TupleLiteralPart, _TupleLiteralPart); |
| addBinding(_OrderedCollection_OclElement, _OclElement); |
| addBinding(_OrderedSet_OclElement_NullFree, _OclElement); |
| addBinding(_Set_CollectionItem, _CollectionItem); |
| addBinding(_Set_Element, _Element); |
| addBinding(_Set_Property, _Property); |
| addBinding(_Set_PseudoOperations_loop_E, tp_PseudoOperations_loop_E); |
| addBinding(_Set_TupleLiteralPart, _TupleLiteralPart); |
| addBinding(_UniqueCollection_CollectionItem, _CollectionItem); |
| addBinding(_UniqueCollection_Element, _Element); |
| addBinding(_UniqueCollection_OclElement, _OclElement); |
| addBinding(_UniqueCollection_Property, _Property); |
| addBinding(_UniqueCollection_PseudoOperations_loop_E, tp_PseudoOperations_loop_E); |
| addBinding(_UniqueCollection_TupleLiteralPart, _TupleLiteralPart); |
| } |
| |
| private void installComments() { |
| installComment(op_PseudoOperations_collection, "The PseudoOperations::collection(items) pseudo-operation provides items to allow a collection construction to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_error, "The PseudoOperations::error(elements) pseudo-operation provides parameters to allow an error construction to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_if, "The PseudoOperations::if(condition, then, else) pseudo-operation provides parameters to allow an IfExp to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_loop, "The PseudoOperations::loop(source, iterators, body) pseudo-operation provides parameters to allow a LoopExp to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_mapPart, "The PseudoOperations::mapPart(key, value) pseudo-operation provides parameters to allow a MapLiteralPart to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_map, "The PseudoOperations::map(parts) pseudo-operation provides parameters to allow a map construction to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_range, "The PseudoOperations::range(first, last) pseudo-operation provides parameters to allow a CollectionRange to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_shadow, "The PseudoOperations::shadow(parts) pseudo-operation provides parameters to allow a shadow Class construction to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_tuple, "The PseudoOperations::tuple(parts) pseudo-operation provides parameters to allow a tuple construction to be treated\nas an Operation within QVTs."); |
| installComment(op_PseudoOperations_type, "The PseudoOperations::type(value) pseudo-operation provides parameters to allow a Type to be treated\nas an Operation within QVTs."); |
| } |
| } |
| } |