| /******************************************************************************* |
| * «codeGenHelper.getCopyright(' * ')» |
| * |
| * This code is 100% auto-generated |
| * using: org.eclipse.ocl.examples.codegen.java.JavaStream |
| * |
| * Do not edit it. |
| ********************************************************************************/ |
| |
| package cg; |
| |
| import classes.ClassesFactory; |
| import classes.ClassesPackage; |
| import classes.Package; |
| import classes.Root; |
| import classescs.ClassCS; |
| import classescs.ClassescsPackage; |
| import classescs.PackageCS; |
| import classescs.RootCS; |
| import classescstraces.ClassCS2Class; |
| import classescstraces.ClassescstracesFactory; |
| import classescstraces.ClassescstracesPackage; |
| import classescstraces.PackageCS2Package; |
| import classescstraces.RootCS2Root; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Map; |
| import org.eclipse.jdt.annotation.NonNull; |
| import org.eclipse.jdt.annotation.Nullable; |
| import org.eclipse.ocl.pivot.evaluation.Evaluator; |
| import org.eclipse.ocl.pivot.ids.ClassId; |
| import org.eclipse.ocl.pivot.ids.CollectionTypeId; |
| import org.eclipse.ocl.pivot.ids.IdManager; |
| import org.eclipse.ocl.pivot.ids.IdResolver; |
| import org.eclipse.ocl.pivot.ids.NsURIPackageId; |
| import org.eclipse.ocl.pivot.ids.RootPackageId; |
| import org.eclipse.ocl.pivot.ids.TypeId; |
| import org.eclipse.ocl.pivot.library.classifier.ClassifierAllInstancesOperation; |
| import org.eclipse.ocl.pivot.library.collection.CollectionAsOrderedSetOperation; |
| import org.eclipse.ocl.pivot.utilities.ClassUtil; |
| import org.eclipse.ocl.pivot.utilities.ValueUtil; |
| import org.eclipse.ocl.pivot.values.InvalidValueException; |
| import org.eclipse.ocl.pivot.values.OrderedSetValue; |
| import org.eclipse.ocl.pivot.values.SequenceValue; |
| import org.eclipse.ocl.pivot.values.SetValue; |
| import org.eclipse.qvtd.pivot.qvtbase.evaluation.AbstractTransformationExecutor; |
| |
| /** |
| * The classescs2as transformation: |
| * <p> |
| * Construct with an evaluator |
| * <br> |
| * Populate each input model with {@link addRootObjects(String,List)} |
| * <br> |
| * {@link run()} |
| * <br> |
| * Extract each output model with {@link getRootObjects(String)} |
| */ |
| @SuppressWarnings("nls") |
| public class classescs2as extends AbstractTransformationExecutor |
| { |
| public static final @NonNull /*@NonInvalid*/ RootPackageId PACKid_$metamodel$ = IdManager.getRootPackageId("$metamodel$"); |
| public static final @NonNull /*@NonInvalid*/ NsURIPackageId PACKid_http_c_s_s_ocldependencyanalysis_s_classes_s_1_0 = IdManager.getNsURIPackageId("http://ocldependencyanalysis/classes/1.0", null, ClassesPackage.eINSTANCE); |
| public static final @NonNull /*@NonInvalid*/ NsURIPackageId PACKid_http_c_s_s_ocldependencyanalysis_s_classescs_s_1_0 = IdManager.getNsURIPackageId("http://ocldependencyanalysis/classescs/1.0", null, ClassescsPackage.eINSTANCE); |
| public static final @NonNull /*@NonInvalid*/ NsURIPackageId PACKid_http_c_s_s_tracesmodel_s_1_0_s_classescstraces = IdManager.getNsURIPackageId("http://tracesmodel/1.0/classescstraces", null, ClassescstracesPackage.eINSTANCE); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_Class = PACKid_http_c_s_s_ocldependencyanalysis_s_classes_s_1_0.getClassId("Class", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_ClassCS = PACKid_http_c_s_s_ocldependencyanalysis_s_classescs_s_1_0.getClassId("ClassCS", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_ClassCS2Class = PACKid_http_c_s_s_tracesmodel_s_1_0_s_classescstraces.getClassId("ClassCS2Class", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_Class_0 = PACKid_$metamodel$.getClassId("Class", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_Package = PACKid_http_c_s_s_ocldependencyanalysis_s_classes_s_1_0.getClassId("Package", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_PackageCS = PACKid_http_c_s_s_ocldependencyanalysis_s_classescs_s_1_0.getClassId("PackageCS", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_PackageCS2Package = PACKid_http_c_s_s_tracesmodel_s_1_0_s_classescstraces.getClassId("PackageCS2Package", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_Root = PACKid_http_c_s_s_ocldependencyanalysis_s_classes_s_1_0.getClassId("Root", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_RootCS = PACKid_http_c_s_s_ocldependencyanalysis_s_classescs_s_1_0.getClassId("RootCS", 0); |
| public static final @NonNull /*@NonInvalid*/ ClassId CLSSid_RootCS2Root = PACKid_http_c_s_s_tracesmodel_s_1_0_s_classescstraces.getClassId("RootCS2Root", 0); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId ORD_CLSSid_Class = TypeId.ORDERED_SET.getSpecializedId(CLSSid_Class); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId ORD_CLSSid_ClassCS = TypeId.ORDERED_SET.getSpecializedId(CLSSid_ClassCS); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId ORD_CLSSid_Package = TypeId.ORDERED_SET.getSpecializedId(CLSSid_Package); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId ORD_CLSSid_PackageCS = TypeId.ORDERED_SET.getSpecializedId(CLSSid_PackageCS); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SEQ_CLSSid_Class = TypeId.SEQUENCE.getSpecializedId(CLSSid_Class); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SEQ_CLSSid_ClassCS2Class = TypeId.SEQUENCE.getSpecializedId(CLSSid_ClassCS2Class); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SEQ_CLSSid_Package = TypeId.SEQUENCE.getSpecializedId(CLSSid_Package); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SEQ_CLSSid_PackageCS2Package = TypeId.SEQUENCE.getSpecializedId(CLSSid_PackageCS2Package); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_Class = TypeId.SET.getSpecializedId(CLSSid_Class); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_ClassCS = TypeId.SET.getSpecializedId(CLSSid_ClassCS); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_ClassCS2Class = TypeId.SET.getSpecializedId(CLSSid_ClassCS2Class); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_Package = TypeId.SET.getSpecializedId(CLSSid_Package); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_PackageCS = TypeId.SET.getSpecializedId(CLSSid_PackageCS); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_PackageCS2Package = TypeId.SET.getSpecializedId(CLSSid_PackageCS2Package); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_Root = TypeId.SET.getSpecializedId(CLSSid_Root); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_RootCS = TypeId.SET.getSpecializedId(CLSSid_RootCS); |
| public static final @NonNull /*@NonInvalid*/ CollectionTypeId SET_CLSSid_RootCS2Root = TypeId.SET.getSpecializedId(CLSSid_RootCS2Root); |
| |
| /* Outer-to-Middle Property navigation caches */ |
| protected final @NonNull Map<ClassCS,ClassCS2Class> OPPOSITE_OF_ClassCS2Class_classCS = new HashMap<ClassCS,ClassCS2Class>(); |
| protected final @NonNull Map<PackageCS,PackageCS2Package> OPPOSITE_OF_PackageCS2Package_packageCS = new HashMap<PackageCS,PackageCS2Package>(); |
| protected final @NonNull Map<RootCS,RootCS2Root> OPPOSITE_OF_RootCS2Root_rootCS = new HashMap<RootCS,RootCS2Root>(); |
| |
| |
| /* |
| * Array of the ClassIds of each class for which allInstances() may be invoked. Array index is the ClassIndex. |
| */ |
| private static final @NonNull ClassId[] classIndex2classId = new ClassId[]{ |
| CLSSid_Class, // 0 => Class |
| CLSSid_ClassCS, // 1 => ClassCS |
| CLSSid_ClassCS2Class, // 2 => ClassCS2Class |
| CLSSid_Package, // 3 => Package |
| CLSSid_PackageCS, // 4 => PackageCS |
| CLSSid_PackageCS2Package, // 5 => PackageCS2Package |
| CLSSid_Root, // 6 => Root |
| CLSSid_RootCS, // 7 => RootCS |
| CLSSid_RootCS2Root // 8 => RootCS2Root |
| }; |
| /* |
| * Mapping from each ClassIndex to all the ClassIndexes to which an object of the outer index |
| * may contribute results to an allInstances() invocation. |
| * Non trivial inner arrays arise when one ClassId is a derivation of another and so an |
| * instance of the derived classId contributes to derived and inherited ClassIndexes. |
| */ |
| private final static @NonNull int[][] classIndex2allClassIndexes = new int[][] { |
| {0}, // 0 : Class -> {Class} |
| {1}, // 1 : ClassCS -> {ClassCS} |
| {2}, // 2 : ClassCS2Class -> {ClassCS2Class} |
| {3}, // 3 : Package -> {Package} |
| {4}, // 4 : PackageCS -> {PackageCS} |
| {5}, // 5 : PackageCS2Package -> {PackageCS2Package} |
| {6}, // 6 : Root -> {Root} |
| {7}, // 7 : RootCS -> {RootCS} |
| {8} // 8 : RootCS2Root -> {RootCS2Root} |
| }; |
| |
| public classescs2as(final @NonNull Evaluator evaluator) { |
| super(evaluator, new String[] {"leftCS", "rightAS", "middle"}, null, classIndex2classId, classIndex2allClassIndexes); |
| } |
| |
| public boolean run() { |
| return __root__(); |
| } |
| |
| /** |
| * |
| * map mClassCS2Class_LM in classescs2as) { |
| * leftCS (classCS : classescs::ClassCS; |
| * | |
| * ) |
| * { | |
| * } |
| * middle ( | |
| * ) |
| * {realize c2c : classescstraces::ClassCS2Class; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * c2c = classCS; |
| * } |
| * |
| * } |
| */ |
| protected boolean mClassCS2Class_LM(final @NonNull /*@NonInvalid*/ ClassCS classCS) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ ClassCS2Class c2c_0 = ClassescstracesFactory.eINSTANCE.createClassCS2Class(); |
| assert c2c_0 != null; |
| modelObjects[2/*middle*/].add(c2c_0); |
| classIndex2objects[2/*ClassCS2Class*/].add(c2c_0); |
| // assignments |
| c2c_0.setClassCS(classCS); |
| OPPOSITE_OF_ClassCS2Class_classCS.put(classCS, c2c_0); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map mRootCS2Root_LM in classescs2as) { |
| * leftCS (rootCS : classescs::RootCS; |
| * | |
| * ) |
| * { | |
| * } |
| * middle ( | |
| * ) |
| * {realize r2r : classescstraces::RootCS2Root; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * r2r = rootCS; |
| * } |
| * |
| * } |
| */ |
| protected boolean mRootCS2Root_LM(final @NonNull /*@NonInvalid*/ RootCS rootCS) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ RootCS2Root r2r_0 = ClassescstracesFactory.eINSTANCE.createRootCS2Root(); |
| assert r2r_0 != null; |
| modelObjects[2/*middle*/].add(r2r_0); |
| classIndex2objects[8/*RootCS2Root*/].add(r2r_0); |
| // assignments |
| r2r_0.setRootCS(rootCS); |
| OPPOSITE_OF_RootCS2Root_rootCS.put(rootCS, r2r_0); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map mPackageCS2Package_LM in classescs2as) { |
| * leftCS (packageCS : classescs::PackageCS; |
| * | |
| * ) |
| * { | |
| * } |
| * middle ( | |
| * ) |
| * {realize p2p : classescstraces::PackageCS2Package; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * p2p = packageCS; |
| * } |
| * |
| * } |
| */ |
| protected boolean mPackageCS2Package_LM(final @NonNull /*@NonInvalid*/ PackageCS packageCS) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ PackageCS2Package p2p_0 = ClassescstracesFactory.eINSTANCE.createPackageCS2Package(); |
| assert p2p_0 != null; |
| modelObjects[2/*middle*/].add(p2p_0); |
| classIndex2objects[5/*PackageCS2Package*/].add(p2p_0); |
| // assignments |
| p2p_0.setPackageCS(packageCS); |
| OPPOSITE_OF_PackageCS2Package_packageCS.put(packageCS, p2p_0); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map mClassCS2Class_MR in classescs2as) { |
| * middle (c2c : classescstraces::ClassCS2Class; |
| * | |
| * ) |
| * { | |
| * } |
| * rightAS ( | |
| * ) |
| * {realize class : classes::Class; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * c2c = class; |
| * } |
| * |
| * } |
| */ |
| protected boolean mClassCS2Class_MR(final @NonNull /*@NonInvalid*/ ClassCS2Class c2c) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ classes.Class symbol_3 = ClassesFactory.eINSTANCE.createClass(); |
| assert symbol_3 != null; |
| modelObjects[1/*rightAS*/].add(symbol_3); |
| classIndex2objects[0/*Class*/].add(symbol_3); |
| // assignments |
| c2c.setClass(symbol_3); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map mRootCS2Root_MR in classescs2as) { |
| * middle (r2r : classescstraces::RootCS2Root; |
| * | |
| * ) |
| * { | |
| * } |
| * rightAS ( | |
| * ) |
| * {realize root : classes::Root; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * r2r = root; |
| * } |
| * |
| * } |
| */ |
| protected boolean mRootCS2Root_MR(final @NonNull /*@NonInvalid*/ RootCS2Root r2r) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ Root root_0 = ClassesFactory.eINSTANCE.createRoot(); |
| assert root_0 != null; |
| modelObjects[1/*rightAS*/].add(root_0); |
| classIndex2objects[6/*Root*/].add(root_0); |
| // assignments |
| r2r.setRoot(root_0); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map mPackageCS2Package_MR in classescs2as) { |
| * middle (p2p : classescstraces::PackageCS2Package; |
| * | |
| * ) |
| * { | |
| * } |
| * rightAS ( | |
| * ) |
| * {realize package : classes::Package; |
| * | |
| * } |
| * where ( | |
| * ) |
| * { | |
| * p2p = package; |
| * } |
| * |
| * } |
| */ |
| protected boolean mPackageCS2Package_MR(final @NonNull /*@NonInvalid*/ PackageCS2Package p2p) { |
| try { |
| // predicates |
| // creations |
| final /*@Thrown*/ Package symbol_3 = ClassesFactory.eINSTANCE.createPackage(); |
| assert symbol_3 != null; |
| modelObjects[1/*rightAS*/].add(symbol_3); |
| classIndex2objects[3/*Package*/].add(symbol_3); |
| // assignments |
| p2p.setPackage(symbol_3); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map uClass_name in classescs2as) { |
| * rightAS (class : classes::Class; |
| * | |
| * ) |
| * { | |
| * } |
| * leftCS (classCS : classescs::ClassCS; |
| * | |
| * ) |
| * { | |
| * } |
| * where ( | |
| * classCS.ClassCS2Class.class = class) |
| * { | |
| * class = classCS.name; |
| * } |
| * |
| * } |
| */ |
| protected boolean uClass_name(final @NonNull /*@NonInvalid*/ classes.Class symbol_0, final @NonNull /*@NonInvalid*/ ClassCS classCS_0) { |
| try { |
| // predicates |
| final @NonNull /*@Thrown*/ ClassCS2Class ClassCS2Class = ClassUtil.nonNullState (OPPOSITE_OF_ClassCS2Class_classCS.get(classCS_0)); |
| final @Nullable /*@Thrown*/ classes.Class symbol_3 = ClassCS2Class.getClass_(); |
| final /*@Thrown*/ boolean eq = symbol_0.equals(symbol_3); |
| if (!eq) { |
| return false; |
| } |
| // creations |
| // assignments |
| final @Nullable /*@Thrown*/ String name = classCS_0.getName(); |
| symbol_0.setName(name); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map uRoot_ownedPackages in classescs2as) { |
| * rightAS (root : classes::Root; |
| * | |
| * ) |
| * { | |
| * } |
| * leftCS (rootCS : classescs::RootCS; |
| * | |
| * ) |
| * { | |
| * } |
| * where ( | |
| * rootCS.RootCS2Root.root = |
| * root) |
| * { | |
| * root = rootCS.ownedPackage.PackageCS2Package.package->asOrderedSet(); |
| * } |
| * |
| * } |
| */ |
| protected boolean uRoot_ownedPackages(final @NonNull /*@NonInvalid*/ Root root, final @NonNull /*@NonInvalid*/ RootCS rootCS_0) { |
| try { |
| // predicates |
| final @NonNull /*@Thrown*/ RootCS2Root RootCS2Root = ClassUtil.nonNullState (OPPOSITE_OF_RootCS2Root_rootCS.get(rootCS_0)); |
| final @Nullable /*@Thrown*/ Root root_0 = RootCS2Root.getRoot(); |
| final /*@Thrown*/ boolean eq = root.equals(root_0); |
| if (!eq) { |
| return false; |
| } |
| final @NonNull /*@NonInvalid*/ IdResolver idResolver = evaluator.getIdResolver(); |
| // creations |
| // assignments |
| final @Nullable /*@Thrown*/ List<PackageCS> ownedPackage = rootCS_0.getOwnedPackage(); |
| assert ownedPackage != null; |
| final @NonNull /*@Thrown*/ OrderedSetValue BOXED_ownedPackage = idResolver.createOrderedSetOfAll(ORD_CLSSid_PackageCS, ownedPackage); |
| @NonNull /*@Thrown*/ SequenceValue.Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(SEQ_CLSSid_PackageCS2Package); |
| @Nullable Iterator<?> ITERATOR__1 = BOXED_ownedPackage.iterator(); |
| @NonNull /*@Thrown*/ SequenceValue collect_0; |
| while (true) { |
| if (!ITERATOR__1.hasNext()) { |
| collect_0 = accumulator; |
| break; |
| } |
| @Nullable /*@NonInvalid*/ PackageCS _1 = (PackageCS)ITERATOR__1.next(); |
| /** |
| * PackageCS2Package |
| */ |
| if (_1 == null) { |
| throw new InvalidValueException("Null source for \'classescstraces::PackageCS2Package::packageCS\'"); |
| } |
| final @NonNull /*@Thrown*/ PackageCS2Package PackageCS2Package = ClassUtil.nonNullState (OPPOSITE_OF_PackageCS2Package_packageCS.get(_1)); |
| // |
| accumulator.add(PackageCS2Package); |
| } |
| @NonNull /*@Thrown*/ SequenceValue.Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(SEQ_CLSSid_Package); |
| @Nullable Iterator<?> ITERATOR__1_0 = collect_0.iterator(); |
| @NonNull /*@Thrown*/ SequenceValue collect; |
| while (true) { |
| if (!ITERATOR__1_0.hasNext()) { |
| collect = accumulator_0; |
| break; |
| } |
| @Nullable /*@NonInvalid*/ PackageCS2Package _1_0 = (PackageCS2Package)ITERATOR__1_0.next(); |
| /** |
| * package |
| */ |
| if (_1_0 == null) { |
| throw new InvalidValueException("Null source for \'classescstraces::PackageCS2Package::package\'"); |
| } |
| final @Nullable /*@Thrown*/ Package symbol_3 = _1_0.getPackage(); |
| // |
| accumulator_0.add(symbol_3); |
| } |
| final @NonNull /*@Thrown*/ OrderedSetValue asOrderedSet = CollectionAsOrderedSetOperation.INSTANCE.evaluate(collect); |
| final List<Package> UNBOXED_asOrderedSet = asOrderedSet.asEcoreObjects(idResolver, Package.class); |
| assert UNBOXED_asOrderedSet != null; |
| root.getOwnedPackages().addAll(UNBOXED_asOrderedSet); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map uPackage_name in classescs2as) { |
| * rightAS (package : classes::Package; |
| * | |
| * ) |
| * { | |
| * } |
| * leftCS (packageCS : classescs::PackageCS; |
| * | |
| * ) |
| * { | |
| * } |
| * where ( | |
| * packageCS.PackageCS2Package.package = package) |
| * { | |
| * package = packageCS.name; |
| * } |
| * |
| * } |
| */ |
| protected boolean uPackage_name(final @NonNull /*@NonInvalid*/ Package symbol_1, final @NonNull /*@NonInvalid*/ PackageCS packageCS_0) { |
| try { |
| // predicates |
| final @NonNull /*@Thrown*/ PackageCS2Package PackageCS2Package = ClassUtil.nonNullState (OPPOSITE_OF_PackageCS2Package_packageCS.get(packageCS_0)); |
| final @Nullable /*@Thrown*/ Package symbol_3 = PackageCS2Package.getPackage(); |
| final /*@Thrown*/ boolean eq = symbol_1.equals(symbol_3); |
| if (!eq) { |
| return false; |
| } |
| // creations |
| // assignments |
| final @Nullable /*@Thrown*/ String name = packageCS_0.getName(); |
| symbol_1.setName(name); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map uPackage_ownedClasses in classescs2as) { |
| * rightAS (package : classes::Package; |
| * | |
| * ) |
| * { | |
| * } |
| * leftCS (packageCS : classescs::PackageCS; |
| * | |
| * ) |
| * { | |
| * } |
| * where ( | |
| * packageCS.PackageCS2Package.package = |
| * package) |
| * { | |
| * package = packageCS.ownedClasses.ClassCS2Class.class->asOrderedSet(); |
| * } |
| * |
| * } |
| */ |
| protected boolean uPackage_ownedClasses(final @NonNull /*@NonInvalid*/ Package symbol_2, final @NonNull /*@NonInvalid*/ PackageCS packageCS_1) { |
| try { |
| // predicates |
| final @NonNull /*@Thrown*/ PackageCS2Package PackageCS2Package = ClassUtil.nonNullState (OPPOSITE_OF_PackageCS2Package_packageCS.get(packageCS_1)); |
| final @Nullable /*@Thrown*/ Package symbol_3 = PackageCS2Package.getPackage(); |
| final /*@Thrown*/ boolean eq = symbol_2.equals(symbol_3); |
| if (!eq) { |
| return false; |
| } |
| final @NonNull /*@NonInvalid*/ IdResolver idResolver = evaluator.getIdResolver(); |
| // creations |
| // assignments |
| final @Nullable /*@Thrown*/ List<ClassCS> ownedClasses = packageCS_1.getOwnedClasses(); |
| assert ownedClasses != null; |
| final @NonNull /*@Thrown*/ OrderedSetValue BOXED_ownedClasses = idResolver.createOrderedSetOfAll(ORD_CLSSid_ClassCS, ownedClasses); |
| @NonNull /*@Thrown*/ SequenceValue.Accumulator accumulator = ValueUtil.createSequenceAccumulatorValue(SEQ_CLSSid_ClassCS2Class); |
| @Nullable Iterator<?> ITERATOR__1 = BOXED_ownedClasses.iterator(); |
| @NonNull /*@Thrown*/ SequenceValue collect_0; |
| while (true) { |
| if (!ITERATOR__1.hasNext()) { |
| collect_0 = accumulator; |
| break; |
| } |
| @Nullable /*@NonInvalid*/ ClassCS _1 = (ClassCS)ITERATOR__1.next(); |
| /** |
| * ClassCS2Class |
| */ |
| if (_1 == null) { |
| throw new InvalidValueException("Null source for \'classescstraces::ClassCS2Class::classCS\'"); |
| } |
| final @NonNull /*@Thrown*/ ClassCS2Class ClassCS2Class = ClassUtil.nonNullState (OPPOSITE_OF_ClassCS2Class_classCS.get(_1)); |
| // |
| accumulator.add(ClassCS2Class); |
| } |
| @NonNull /*@Thrown*/ SequenceValue.Accumulator accumulator_0 = ValueUtil.createSequenceAccumulatorValue(SEQ_CLSSid_Class); |
| @Nullable Iterator<?> ITERATOR__1_0 = collect_0.iterator(); |
| @NonNull /*@Thrown*/ SequenceValue collect; |
| while (true) { |
| if (!ITERATOR__1_0.hasNext()) { |
| collect = accumulator_0; |
| break; |
| } |
| @Nullable /*@NonInvalid*/ ClassCS2Class _1_0 = (ClassCS2Class)ITERATOR__1_0.next(); |
| /** |
| * class |
| */ |
| if (_1_0 == null) { |
| throw new InvalidValueException("Null source for \'classescstraces::ClassCS2Class::class\'"); |
| } |
| final @Nullable /*@Thrown*/ classes.Class symbol_4 = _1_0.getClass_(); |
| // |
| accumulator_0.add(symbol_4); |
| } |
| final @NonNull /*@Thrown*/ OrderedSetValue asOrderedSet = CollectionAsOrderedSetOperation.INSTANCE.evaluate(collect); |
| final List<classes.Class> UNBOXED_asOrderedSet = asOrderedSet.asEcoreObjects(idResolver, classes.Class.class); |
| assert UNBOXED_asOrderedSet != null; |
| symbol_2.getOwnedClasses().addAll(UNBOXED_asOrderedSet); |
| // mapping statements |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| |
| /** |
| * |
| * map __root__ in classescs2as) { |
| * |
| * where ( | |
| * ) |
| * { | |
| * } |
| * for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() |
| * { |
| * map mPackageCS2Package_LM { |
| * packageCS := packageCS; |
| * }} |
| * for p2p : classescstraces::PackageCS2Package in classescstraces::PackageCS2Package.allInstances() |
| * { |
| * map mPackageCS2Package_MR { |
| * p2p := p2p; |
| * }} |
| * for package : classes::Package in classes::Package.allInstances() |
| * { |
| * |
| * for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() |
| * { |
| * map uPackage_name { |
| * packageCS := packageCS; |
| * package := package; |
| * }}} |
| * for classCS : classescs::ClassCS in classescs::ClassCS.allInstances() |
| * { |
| * map mClassCS2Class_LM { |
| * classCS := classCS; |
| * }} |
| * for c2c : classescstraces::ClassCS2Class in classescstraces::ClassCS2Class.allInstances() |
| * { |
| * map mClassCS2Class_MR { |
| * c2c := c2c; |
| * }} |
| * for package : classes::Package in classes::Package.allInstances() |
| * { |
| * |
| * for packageCS : classescs::PackageCS in classescs::PackageCS.allInstances() |
| * { |
| * |
| * map uPackage_ownedClasses { |
| * packageCS := packageCS; |
| * package := package; |
| * }}} |
| * for classCS : classescs::ClassCS in classescs::ClassCS.allInstances() |
| * { |
| * |
| * for class : classes::Class in classes::Class.allInstances() |
| * { |
| * map uClass_name { |
| * class := class; |
| * classCS := classCS; |
| * }}} |
| * for rootCS : classescs::RootCS in classescs::RootCS.allInstances() |
| * { |
| * map mRootCS2Root_LM { |
| * rootCS := rootCS; |
| * }} |
| * for r2r : classescstraces::RootCS2Root in classescstraces::RootCS2Root.allInstances() |
| * { |
| * map mRootCS2Root_MR { |
| * r2r := r2r; |
| * }} |
| * for rootCS : classescs::RootCS in classescs::RootCS.allInstances() |
| * { |
| * |
| * for root : classes::Root in classes::Root.allInstances() |
| * { |
| * map uRoot_ownedPackages { |
| * root := root; |
| * rootCS := rootCS; |
| * }}} |
| * } |
| */ |
| protected boolean __root__() { |
| try { |
| // predicates |
| final @NonNull /*@NonInvalid*/ IdResolver idResolver = evaluator.getIdResolver(); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classes_c_c_Package_1 = idResolver.getClass(CLSSid_Package, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescs_c_c_ClassCS_1 = idResolver.getClass(CLSSid_ClassCS, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescs_c_c_PackageCS_0 = idResolver.getClass(CLSSid_PackageCS, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescs_c_c_RootCS_1 = idResolver.getClass(CLSSid_RootCS, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescstraces_c_c_ClassCS2Class_0 = idResolver.getClass(CLSSid_ClassCS2Class, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescstraces_c_c_PackageCS2Package_0 = idResolver.getClass(CLSSid_PackageCS2Package, null); |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classescstraces_c_c_RootCS2Root_0 = idResolver.getClass(CLSSid_RootCS2Root, null); |
| final @Nullable /*@Thrown*/ SetValue allInstances_5 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_Package, TYP_classes_c_c_Package_1); |
| final List<Package> UNBOXED_allInstances_5 = allInstances_5.asEcoreObjects(idResolver, Package.class); |
| assert UNBOXED_allInstances_5 != null; |
| final @Nullable /*@Thrown*/ SetValue allInstances_7 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_ClassCS, TYP_classescs_c_c_ClassCS_1); |
| final List<ClassCS> UNBOXED_allInstances_7 = allInstances_7.asEcoreObjects(idResolver, ClassCS.class); |
| assert UNBOXED_allInstances_7 != null; |
| final @Nullable /*@Thrown*/ SetValue allInstances = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_PackageCS, TYP_classescs_c_c_PackageCS_0); |
| final List<PackageCS> UNBOXED_allInstances = allInstances.asEcoreObjects(idResolver, PackageCS.class); |
| assert UNBOXED_allInstances != null; |
| final @Nullable /*@Thrown*/ SetValue allInstances_11 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_RootCS, TYP_classescs_c_c_RootCS_1); |
| final List<RootCS> UNBOXED_allInstances_11 = allInstances_11.asEcoreObjects(idResolver, RootCS.class); |
| assert UNBOXED_allInstances_11 != null; |
| // creations |
| // assignments |
| // mapping statements |
| ; |
| for (PackageCS packageCS_5 : UNBOXED_allInstances) { |
| if (packageCS_5 != null) { |
| final @NonNull /*@NonInvalid*/ PackageCS symbol_7 = (PackageCS)packageCS_5; |
| mPackageCS2Package_LM(symbol_7); |
| } |
| } |
| final @Nullable /*@Thrown*/ SetValue allInstances_0 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_PackageCS2Package, TYP_classescstraces_c_c_PackageCS2Package_0); |
| final List<PackageCS2Package> UNBOXED_allInstances_0 = allInstances_0.asEcoreObjects(idResolver, PackageCS2Package.class); |
| assert UNBOXED_allInstances_0 != null; |
| ; |
| for (PackageCS2Package p2p_1 : UNBOXED_allInstances_0) { |
| if (p2p_1 != null) { |
| final @NonNull /*@NonInvalid*/ PackageCS2Package symbol_11 = (PackageCS2Package)p2p_1; |
| mPackageCS2Package_MR(symbol_11); |
| } |
| } |
| ; |
| for (Package symbol_21 : UNBOXED_allInstances_5) { |
| if (symbol_21 != null) { |
| ; |
| for (PackageCS packageCS_6 : UNBOXED_allInstances) { |
| if (packageCS_6 != null) { |
| final @NonNull /*@NonInvalid*/ Package symbol_16 = (Package)symbol_21; |
| final @NonNull /*@NonInvalid*/ PackageCS symbol_17 = (PackageCS)packageCS_6; |
| uPackage_name(symbol_16, symbol_17); |
| } |
| } |
| } |
| } |
| ; |
| for (ClassCS classCS_3 : UNBOXED_allInstances_7) { |
| if (classCS_3 != null) { |
| final @NonNull /*@NonInvalid*/ ClassCS symbol_23 = (ClassCS)classCS_3; |
| mClassCS2Class_LM(symbol_23); |
| } |
| } |
| final @Nullable /*@Thrown*/ SetValue allInstances_4 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_ClassCS2Class, TYP_classescstraces_c_c_ClassCS2Class_0); |
| final List<ClassCS2Class> UNBOXED_allInstances_4 = allInstances_4.asEcoreObjects(idResolver, ClassCS2Class.class); |
| assert UNBOXED_allInstances_4 != null; |
| ; |
| for (ClassCS2Class c2c_1 : UNBOXED_allInstances_4) { |
| if (c2c_1 != null) { |
| final @NonNull /*@NonInvalid*/ ClassCS2Class symbol_27 = (ClassCS2Class)c2c_1; |
| mClassCS2Class_MR(symbol_27); |
| } |
| } |
| ; |
| for (Package symbol_37 : UNBOXED_allInstances_5) { |
| if (symbol_37 != null) { |
| ; |
| for (PackageCS packageCS_7 : UNBOXED_allInstances) { |
| if (packageCS_7 != null) { |
| final @NonNull /*@NonInvalid*/ Package symbol_32 = (Package)symbol_37; |
| final @NonNull /*@NonInvalid*/ PackageCS symbol_33 = (PackageCS)packageCS_7; |
| uPackage_ownedClasses(symbol_32, symbol_33); |
| } |
| } |
| } |
| } |
| ; |
| for (ClassCS classCS_4 : UNBOXED_allInstances_7) { |
| if (classCS_4 != null) { |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classes_c_c_Class_0 = idResolver.getClass(CLSSid_Class, null); |
| final @Nullable /*@Thrown*/ SetValue allInstances_8 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_Class, TYP_classes_c_c_Class_0); |
| final List<classes.Class> UNBOXED_allInstances_8 = allInstances_8.asEcoreObjects(idResolver, classes.Class.class); |
| assert UNBOXED_allInstances_8 != null; |
| ; |
| for (classes.Class symbol_44 : UNBOXED_allInstances_8) { |
| if (symbol_44 != null) { |
| final @NonNull /*@NonInvalid*/ classes.Class symbol_40 = (classes.Class)symbol_44; |
| final @NonNull /*@NonInvalid*/ ClassCS symbol_41 = (ClassCS)classCS_4; |
| uClass_name(symbol_40, symbol_41); |
| } |
| } |
| } |
| } |
| ; |
| for (RootCS rootCS_3 : UNBOXED_allInstances_11) { |
| if (rootCS_3 != null) { |
| final @NonNull /*@NonInvalid*/ RootCS symbol_47 = (RootCS)rootCS_3; |
| mRootCS2Root_LM(symbol_47); |
| } |
| } |
| final @Nullable /*@Thrown*/ SetValue allInstances_10 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_RootCS2Root, TYP_classescstraces_c_c_RootCS2Root_0); |
| final List<RootCS2Root> UNBOXED_allInstances_10 = allInstances_10.asEcoreObjects(idResolver, RootCS2Root.class); |
| assert UNBOXED_allInstances_10 != null; |
| ; |
| for (RootCS2Root r2r_1 : UNBOXED_allInstances_10) { |
| if (r2r_1 != null) { |
| final @NonNull /*@NonInvalid*/ RootCS2Root symbol_51 = (RootCS2Root)r2r_1; |
| mRootCS2Root_MR(symbol_51); |
| } |
| } |
| ; |
| for (RootCS rootCS_4 : UNBOXED_allInstances_11) { |
| if (rootCS_4 != null) { |
| final @NonNull /*@NonInvalid*/ org.eclipse.ocl.pivot.Class TYP_classes_c_c_Root_0 = idResolver.getClass(CLSSid_Root, null); |
| final @Nullable /*@Thrown*/ SetValue allInstances_12 = ClassifierAllInstancesOperation.INSTANCE.evaluate(evaluator, SET_CLSSid_Root, TYP_classes_c_c_Root_0); |
| final List<Root> UNBOXED_allInstances_12 = allInstances_12.asEcoreObjects(idResolver, Root.class); |
| assert UNBOXED_allInstances_12 != null; |
| ; |
| for (Root root_1 : UNBOXED_allInstances_12) { |
| if (root_1 != null) { |
| final @NonNull /*@NonInvalid*/ Root symbol_56 = (Root)root_1; |
| final @NonNull /*@NonInvalid*/ RootCS symbol_57 = (RootCS)rootCS_4; |
| uRoot_ownedPackages(symbol_56, symbol_57); |
| } |
| } |
| } |
| } |
| return true; |
| } |
| catch (Exception e) { |
| return false; |
| } |
| } |
| } |
