public void test_target() throws Exception { this.addNodeById("2906110183022219846"); this.addNodeById("2906110183022219807"); this.addNodeById("2906110183022219843"); this.addNodeById("2906110183022354865"); this.addNodeById("2906110183022432276"); TestUtilities.assertEquals( Sequence.fromArray( new SNode[] { SNodeOperations.cast( this.getNodeById("2906110183022219847"), "jetbrains.mps.lang.smodelTests.structure.Root"), SNodeOperations.cast( this.getNodeById("2906110183022219848"), "jetbrains.mps.lang.smodelTests.structure.Child"), SNodeOperations.cast( this.getNodeById("2906110183022311236"), "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept") }), Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022219844"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"))) .select( new ISelector<SReference, SNode>() { public SNode select(SReference it) { return SLinkOperations.getTargetNode(it); } })); }
public static Scope virtual_getProjectStructureScope_3734116213129936182( SNode thisNode, final SNode kind) { if (SConceptOperations.isSubConceptOf( kind, "jetbrains.mps.build.mps.structure.BuildMps_AbstractModule") || SConceptOperations.isSubConceptOf( kind, "jetbrains.mps.build.mps.structure.BuildMps_IdeaPlugin") || SConceptOperations.isSubConceptOf( kind, "jetbrains.mps.build.mps.structure.BuildMps_Group")) { return new CompositeScope( Sequence.fromIterable( BuildProject_Behavior.call_getVisibleProjects_1224588814561807665( BuildPlugin_Behavior.call_getProject_1224588814561866657(thisNode), false)) .select( new ISelector<SNode, DescendantsScope>() { public DescendantsScope select(SNode it) { return DescendantsScope.forNamedElements( it, SLinkOperations.findLinkDeclaration( "jetbrains.mps.build.structure.BuildProject", "parts"), kind); } }) .concat( Sequence.fromIterable( Sequence.<DescendantsScope>singleton( DescendantsScope.forNamedElements( BuildPlugin_Behavior.call_getProject_1224588814561866657(thisNode), SLinkOperations.findLinkDeclaration( "jetbrains.mps.build.structure.BuildProject", "parts"), kind)))) .toGenericArray(DescendantsScope.class)); } return null; }
public void test_childrenByLinkDeclarationSpecialized() throws Exception { this.addNodeById("8758390115029078425"); this.addNodeById("5815925154349132136"); this.addNodeById("2166349271756548530"); TestUtilities.assertEquals( Sequence.fromArray( new SNode[] { SNodeOperations.cast( this.getNodeById("2600026384779198859"), "jetbrains.mps.lang.smodelTests.structure.GrandChild") }), SNodeOperations.getChildren( SNodeOperations.cast( this.getNodeById("8758390115029078430"), "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept"), SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept", "specializedGranChild_0_1"))); TestUtilities.assertEquals( Sequence.fromArray( new SNode[] { SNodeOperations.cast( this.getNodeById("2600026384779198859"), "jetbrains.mps.lang.smodelTests.structure.GrandChild") }), SNodeOperations.getChildren( SNodeOperations.cast( this.getNodeById("8758390115029078430"), "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept"), SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.Child", "grandChild_0_1"))); }
private Iterable<String> getCommandsFromItem(Object item) { if (item == null) { return ListSequence.fromList(new ArrayList<String>()); } if (item instanceof String) { if (isNotEmptyString(((String) item))) { return ProcessHandlerBuilder.splitCommandInParts((String) item); } } else if (item instanceof File) { String path = ((File) item).getAbsolutePath(); if ((path != null && path.length() > 0)) { return Sequence.<String>singleton(path); } } else if (item instanceof CommandPart) { return ((CommandPart) item).getCommandList(); } else if (item instanceof Iterable) { List<String> result = ListSequence.fromList(new ArrayList<String>()); for (Object it : (Iterable) item) { ListSequence.fromList(result).addSequence(Sequence.fromIterable(getCommandsFromItem(it))); } return result; } else { if (LOG.isEnabledFor(Priority.ERROR)) { LOG.error("Unknown type of command part " + item); } } return ListSequence.fromList(new ArrayList<String>()); }
public Iterable<SNode> getAvailableElements(@Nullable String prefix) { List<SNode> result = new ArrayList<SNode>(); ListSequence.fromList(result) .addSequence( Sequence.fromIterable(scope.getAvailableElements(prefix)) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return it.isInstanceOfConcept(kindConceptFqName); } })); ListSequence.fromList(result) .addSequence( Sequence.fromIterable(parentScope.getAvailableElements(prefix)) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return it.isInstanceOfConcept(kindConceptFqName); } }) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return !(it.isInstanceOfConcept(hidingRootConceptFqName)) || !(SetSequence.fromSet(names).contains(it.getName())); } })); return result; }
public void doExecute(@NotNull final AnActionEvent event, final Map<String, Object> _params) { try { for (SModel model : Sequence.fromIterable( ((MPSProject) MapSequence.fromMap(_params).get("mpsProject")).getProjectModels())) { if (!(model instanceof RefactorableSModelDescriptor)) { continue; } if (SModelStereotype.isStubModelStereotype(SModelStereotype.getStereotype(model))) { continue; } UpdateRefactoringVersions_Action.this.updateModelVersion( (RefactorableSModelDescriptor) model, _params); } for (SModel model : Sequence.fromIterable( ((MPSProject) MapSequence.fromMap(_params).get("mpsProject")).getProjectModels())) { if (!(model instanceof EditableSModelDescriptor)) { continue; } if (SModelStereotype.isStubModelStereotype(SModelStereotype.getStereotype(model))) { continue; } UpdateRefactoringVersions_Action.this.updateImportVersions( (EditableSModelDescriptor) model, _params); } SModelRepository.getInstance().saveAll(); } catch (Throwable t) { LOG.error("User's action execute method failed. Action:" + "UpdateRefactoringVersions", t); } }
public void collectRequired(Iterable<SModule> pool) { Set<SModuleReference> allRequired = SetSequence.fromSetWithValues( new HashSet<SModuleReference>(), Sequence.fromIterable(MapSequence.fromMap(allDeps).values()) .translate( new ITranslator2<ModulesCluster.ModuleDeps, SModuleReference>() { public Iterable<SModuleReference> translate(ModulesCluster.ModuleDeps dep) { return dep.required; } })); List<SModule> available = Sequence.fromIterable(pool).toListSequence(); int atSize; do { atSize = MapSequence.fromMap(allDeps).count(); for (Iterator<SModule> it = ListSequence.fromList(available).iterator(); it.hasNext(); ) { SModule mod = it.next(); SModuleReference mr = mod.getModuleReference(); if (SetSequence.fromSet(allRequired).contains(mr)) { primAdd(mod); SetSequence.fromSet(allRequired) .addSequence(ListSequence.fromList(MapSequence.fromMap(allDeps).get(mr).required)); it.remove(); } } } while (atSize < MapSequence.fromMap(allDeps).count()); }
private Iterable<SNode> getOperatorContainers() { Iterable<SNode> visibleContainers = ListSequence.fromList( SModelOperations.getRoots( myModel, "jetbrains.mps.baseLanguage.overloadedOperators.structure.ContainerImport")) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return (SLinkOperations.getTarget(it, "container", false) != null); } }) .select( new ISelector<SNode, SNode>() { public SNode select(SNode it) { return SLinkOperations.getTarget(it, "container", false); } }); if (Sequence.fromIterable(visibleContainers).isEmpty()) { visibleContainers = SModelOperations.getRootsIncludingImported( myModel, "jetbrains.mps.baseLanguage.overloadedOperators.structure.OverloadedOperatorContainer"); } return Sequence.fromIterable(visibleContainers) .translate( new ITranslator2<SNode, SNode>() { public Iterable<SNode> translate(SNode it) { return SLinkOperations.getTargets(it, "operators", true); } }); }
public void test_roles() throws Exception { this.addNodeById("2906110183022219846"); this.addNodeById("2906110183022219807"); this.addNodeById("2906110183022219843"); this.addNodeById("2906110183022354865"); this.addNodeById("2906110183022432276"); TestUtilities.assertEquals( Sequence.fromArray( new String[] { SPropertyOperations.getString( SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "root"), "role"), SPropertyOperations.getString( SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "leftChild"), "role"), SPropertyOperations.getString( SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "rightChild"), "role") }), Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022219844"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"))) .select( new ISelector<SReference, String>() { public String select(SReference it) { return SLinkOperations.getRole(it); } })); }
public List<SNode> getFields() { List<SNode> result = new ArrayList<SNode>(); ListSequence.fromList(result) .addSequence(Sequence.fromIterable(MapSequence.fromMap(myFieldsByName).values())); ListSequence.fromList(result) .addSequence(Sequence.fromIterable(MapSequence.fromMap(myStaticFieldsByName).values())); return result; }
@Nullable public static ITestNodeWrapper tryToWrap(@NotNull SNode node) { for (TestNodeWrapperFactory factory : Sequence.fromIterable(Sequence.fromArray(TestNodeWrapperFactory.values()))) { if (factory.canWrap(node)) { return factory.wrap(node); } } return null; }
public static List<SNode> virtual_getOwnMethods_1906502351318572840(SNode thisNode) { List<SNode> baseMethodDeclarations = new ArrayList<SNode>(); ListSequence.fromList(baseMethodDeclarations) .addSequence( Sequence.fromIterable(Classifier_Behavior.call_methods_5292274854859311639(thisNode))); ListSequence.fromList(baseMethodDeclarations) .addSequence( Sequence.fromIterable( ClassConcept_Behavior.call_staticMethods_5292274854859435867(thisNode))); return baseMethodDeclarations; }
private void addTypeParams(PsiTypeParameterListOwner from, SNode to) { ListSequence.fromList(SLinkOperations.getTargets(to, "typeVariableDeclaration", true)) .addSequence( Sequence.fromIterable(Sequence.fromArray(from.getTypeParameters())) .select( new ISelector<PsiTypeParameter, SNode>() { public SNode select(PsiTypeParameter it) { return convertTypeParameter(it); } })); }
public MPSModulesClosure generationDependenciesClosure() { // direct and indirect dependencies of used languages and their runtimes; source languages of // generators involved for (SNode m : Sequence.fromIterable(initialModules)) { Iterable<SNode> usedLanguages = getUsedLanguages(m); collectDependencies(usedLanguages, false); collectAllUsedLanguageRuntimesAndTheirDeps(usedLanguages); modules.addAll(Sequence.fromIterable(usedLanguages).toListSequence()); collectGeneratorsDependendencies(usedLanguages); } return this; }
public void test_unspecifiedReferences() throws Exception { this.addNodeById("2906110183022219846"); this.addNodeById("2906110183022219807"); this.addNodeById("2906110183022219843"); this.addNodeById("2906110183022354865"); this.addNodeById("2906110183022432276"); // Adding one unspecified reference and checking if it was added properly int initialSize = Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022432277"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"))) .count(); String unspecifiedReferenceName = this.addUnspecifiedReference( SNodeOperations.cast( this.getNodeById("2906110183022432277"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"), SNodeOperations.cast( this.getNodeById("2906110183022219849"), "jetbrains.mps.lang.smodelTests.structure.GrandChild")); Assert.assertEquals( initialSize + 1, Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022432277"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"))) .count()); // Checking if unspecified reference is working properly Iterable<SReference> unspecifiedReferences = Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022432277"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer"))) .where( new IWhereFilter<SReference>() { public boolean accept(SReference it) { return (SLinkOperations.findLinkDeclaration(it) == null); } }); Assert.assertEquals(1, Sequence.fromIterable(unspecifiedReferences).count()); SReference theReference = Sequence.fromIterable(unspecifiedReferences).first(); Assert.assertEquals(unspecifiedReferenceName, SLinkOperations.getRole(theReference)); Assert.assertEquals( SNodeOperations.cast( this.getNodeById("2906110183022219849"), "jetbrains.mps.lang.smodelTests.structure.GrandChild"), SLinkOperations.getTargetNode(theReference)); }
private void collectDependencies(Iterable<SNode> sequence, boolean reexportOnly) { if (Sequence.fromIterable(sequence).isEmpty()) { return; } Set<SNode> dependencies = SetSequence.fromSet(new HashSet<SNode>()); for (SNode module : Sequence.fromIterable(sequence)) { SetSequence.fromSet(dependencies) .addSequence(Sequence.fromIterable(getDependencies(module, reexportOnly))); } SetSequence.fromSet(dependencies).removeSequence(SetSequence.fromSet(modules)); modules.addAll(dependencies); collectDependencies(dependencies, reexportOnly); }
public MPSModulesClosure designtimeClosure() { // direct and indirect dependencies of the modules, languages used and their runtimes collectDependencies(initialModules, false); collectAllUsedLanguageRuntimesAndTheirDeps(initialModules); for (SNode m : Sequence.fromIterable(initialModules)) { Iterable<SNode> usedLanguages = getUsedLanguages(m); collectDependencies(usedLanguages, false); collectAllUsedLanguageRuntimesAndTheirDeps(usedLanguages); modules.addAll(Sequence.fromIterable(usedLanguages).toListSequence()); } modules.removeAll(Sequence.fromIterable(initialModules).toListSequence()); return this; }
public void test_forSpecializedLink() throws Exception { this.addNodeById("2906110183022219846"); this.addNodeById("2906110183022219807"); this.addNodeById("2906110183022219843"); this.addNodeById("2906110183022354865"); this.addNodeById("2906110183022432276"); TestUtilities.assertEquals( Sequence.fromArray( new SNode[] { SNodeOperations.cast( this.getNodeById("2906110183022311236"), "jetbrains.mps.lang.smodelTests.structure.ChildSubConcept") }), Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022354866"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept"))) .where( new IWhereFilter<SReference>() { public boolean accept(SReference it) { return SLinkOperations.findLinkDeclaration(it) == SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ReferenceContainer", "rightChild"); } }) .select( new ISelector<SReference, SNode>() { public SNode select(SReference it) { return SLinkOperations.getTargetNode(it); } })); Assert.assertTrue( Sequence.fromIterable( SNodeOperations.getReferences( SNodeOperations.cast( this.getNodeById("2906110183022354866"), "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept"))) .where( new IWhereFilter<SReference>() { public boolean accept(SReference it) { return SLinkOperations.findLinkDeclaration(it) == SLinkOperations.findLinkDeclaration( "jetbrains.mps.lang.smodelTests.structure.ReferenceContainerSubConcept", "specializedRightChild"); } }) .isEmpty()); }
public MPSModulesClosure runtimeDependencies() { // direct dependencies of used languages' runtime solutions if (Sequence.fromIterable(initialModules).count() != 1) { throw new IllegalStateException("cannot build runtime dependencies for several modules"); } SNode initial = Sequence.fromIterable(initialModules).first(); Set<SNode> langs = SetSequence.fromSet(new HashSet<SNode>()); Set<SNode> solutions = SetSequence.fromSet(new HashSet<SNode>()); fillUsedLanguageRuntimes(initial, langs, solutions); modules.addAll(solutions); languagesWithRuntime.addAll(langs); return this; }
private void collectAllUsedLanguageRuntimesAndTheirDeps(Iterable<SNode> sequence) { if (Sequence.fromIterable(sequence).isEmpty()) { return; } Set<SNode> langs = SetSequence.fromSet(new HashSet<SNode>()); Set<SNode> solutions = SetSequence.fromSet(new HashSet<SNode>()); for (SNode module : Sequence.fromIterable(sequence)) { fillUsedLanguageRuntimes(module, langs, solutions); } SetSequence.fromSet(solutions).removeSequence(SetSequence.fromSet(modules)); modules.addAll(solutions); languagesWithRuntime.addAll(langs); collectDependencies(((Iterable<SNode>) solutions), false); collectAllUsedLanguageRuntimesAndTheirDeps(((Iterable<SNode>) solutions)); }
private static List<SNode> getParameters_id5keEkmeCqHW(@NotNull SNode __thisNode__) { if (CommandDeclaration_BehaviorDescriptor.isDebuggable_idJzCdmU6yOQ.invoke( ExecuteCommandPart_BehaviorDescriptor.getCommandDeclaration_id5keEkmeCqIg.invoke( __thisNode__))) { return ListSequence.fromList( SLinkOperations.getChildren( __thisNode__, MetaAdapterFactory.getContainmentLink( 0xf3347d8a0e794f35L, 0x8ac91574f25c986fL, 0x550ea9458ea107acL, 0x550ea9458ea107adL, "parameterDeclaration"))) .select( new ISelector<SNode, SNode>() { public SNode select(SNode it) { return SNodeOperations.cast( it, MetaAdapterFactory.getConcept( 0xf3347d8a0e794f35L, 0x8ac91574f25c986fL, 0x65afee7b2c712158L, "jetbrains.mps.execution.commands.structure.CommandParameterDeclaration")); } }) .union( Sequence.fromIterable( Sequence.<SNode>singleton( SLinkOperations.getTarget( ExecuteCommandPart_BehaviorDescriptor.getCommandDeclaration_id5keEkmeCqIg .invoke(__thisNode__), MetaAdapterFactory.getContainmentLink( 0xf3347d8a0e794f35L, 0x8ac91574f25c986fL, 0xbe3a0d5ba1a2be8L, 0x75aadb0d4e6223baL, "debuggerParameter"))))) .toListSequence(); } return SLinkOperations.getChildren( __thisNode__, MetaAdapterFactory.getContainmentLink( 0xf3347d8a0e794f35L, 0x8ac91574f25c986fL, 0x550ea9458ea107acL, 0x550ea9458ea107adL, "parameterDeclaration")); }
public Map<SReference, SNode> classifyUsages(Iterable<SReference> usages) { Map<SReference, SNode> result = MapSequence.fromMap(new HashMap<SReference, SNode>()); for (SReference ref : Sequence.fromIterable(usages)) { MapSequence.fromMap(result).put(ref, ref.getTargetNode()); } return result; }
public static Iterable<Element> children(Element container, String tagName) { if (container == null) { return Sequence.fromIterable(Collections.<Element>emptyList()); } return (Iterable<Element>) ((List<Element>) container.getChildren(tagName)); }
public Iterable<IFacet.Name> required() { return Sequence.fromArray( new IFacet.Name[] { new IFacet.Name("jetbrains.mps.lang.core.Generate"), new IFacet.Name("jetbrains.mps.lang.core.Make") }); }
public Iterable<ITarget.Name> before() { return Sequence.fromArray( new ITarget.Name[] { new ITarget.Name("jetbrains.mps.lang.core.Make.reconcile"), new ITarget.Name("jetbrains.mps.lang.core.Make.make") }); }
public static boolean baseMappingRule_Condition_2379134940425784781( final IOperationContext operationContext, final BaseMappingRuleContext _context) { boolean methodHasDispatchModifier = SNodeOperations.isInstanceOf( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration") && ListSequence.fromList( SLinkOperations.getTargets( SNodeOperations.cast( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration"), "modifiers", true)) .any( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SNodeOperations.isInstanceOf( it, "jetbrains.mps.baseLanguage.doubleDispatch.structure.DispatchModifier"); } }); return methodHasDispatchModifier && Sequence.fromIterable( DispatchGenUtil.getMatchingMethods( SNodeOperations.cast( SNodeOperations.getParent(_context.getNode()), "jetbrains.mps.baseLanguage.structure.MethodDeclaration"))) .isNotEmpty(); }
protected Set<IModule> getInitialModules() { Set<IModule> result = SetSequence.fromSet(new HashSet<IModule>()); SetSequence.fromSet(result).addElement(DiffTemporaryModule.this); SetSequence.fromSet(result) .addSequence(Sequence.fromIterable(GlobalScope.getInstance().getVisibleModules())); return result; }
private Iterable<SNode> getFieldDeclarationsWithoutGetterOrSetter( final SNode classConcept, final Map<String, Object> _params) { final Project project = ((EditorContext) MapSequence.fromMap(_params).get("editorContext")) .getOperationContext() .getProject(); return Sequence.fromIterable( BehaviorReflection.invokeNonVirtual( (Class<Iterable<SNode>>) ((Class) Object.class), classConcept, "jetbrains.mps.baseLanguage.structure.ClassConcept", "call_fields_5292274854859383272", new Object[] {})) .where( new IWhereFilter<SNode>() { public boolean accept(SNode field) { final String setterName = GenerateGettersAndSettersUtil.getFieldSetterName(field, project); final String getterName = GenerateGettersAndSettersUtil.getFieldGetterName(field, project); return !(Sequence.fromIterable( BehaviorReflection.invokeNonVirtual( (Class<Iterable<SNode>>) ((Class) Object.class), classConcept, "jetbrains.mps.baseLanguage.structure.Classifier", "call_methods_5292274854859311639", new Object[] {})) .any( new IWhereFilter<SNode>() { public boolean accept(SNode method) { return getterName.equals( SPropertyOperations.getString(method, "name")) && ListSequence.fromList( SLinkOperations.getTargets(method, "parameter", true)) .isEmpty(); } })) && !(Sequence.fromIterable( BehaviorReflection.invokeNonVirtual( (Class<Iterable<SNode>>) ((Class) Object.class), classConcept, "jetbrains.mps.baseLanguage.structure.Classifier", "call_methods_5292274854859311639", new Object[] {})) .any( new IWhereFilter<SNode>() { public boolean accept(SNode method) { return setterName.equals( SPropertyOperations.getString(method, "name")) && (int) ListSequence.fromList( SLinkOperations.getTargets( method, "parameter", true)) .count() == 1; } })); } }); }
public static SNode templateFragment_ContextNodeQuery_3618324829955828392( final TemplateFragmentContext _context) { SNode demoApp = SNodeOperations.cast( _context.getMainContextNode(), MetaAdapterFactory.getConcept( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8c108ca66L, "jetbrains.mps.baseLanguage.structure.ClassConcept")); SNode method = Sequence.fromIterable( ClassConcept_BehaviorDescriptor.staticMethods_id4_LVZ3pCeXr.invoke(demoApp)) .where( new IWhereFilter<SNode>() { public boolean accept(SNode it) { return SPropertyOperations.getString( it, MetaAdapterFactory.getProperty( 0xceab519525ea4f22L, 0x9b92103b95ca8c0cL, 0x110396eaaa4L, 0x110396ec041L, "name")) .equals("addContent"); } }) .first(); return SLinkOperations.getTarget( method, MetaAdapterFactory.getContainmentLink( 0xf3061a5392264cc5L, 0xa443f952ceaf5816L, 0xf8cc56b1fcL, 0xf8cc56b1ffL, "body")); }
@Override protected void doInit() { DependencyTree tree = (DependencyTree) getTree(); for (DepPath c : Sequence.fromIterable(myCycles).distinct()) { Iterator<DepLink> itr = Sequence.fromIterable(c.elements()).iterator(); // skip first path element, which is always the one from my getCapturedDependencies() itr.next(); MPSTreeNode parent = this; while (itr.hasNext()) { DependencyTreeNode dtn = new DependencyTreeNode(tree.getProject(), itr.next()); parent.add(dtn); parent = dtn; } } myInitialized = true; }