@Override public void clear(SNode node, EditorComponent component) { SNodeReference sNodePointer = component.getEditedNodePointer(); if (sNodePointer == null) { return; } LanguageErrorsComponent errorsComponent = MapSequence.fromMap(myNodePointersToComponents).get(sNodePointer); if (errorsComponent == null) { return; } errorsComponent.clear(); }
@Override public void doDispose() { for (LanguageErrorsComponent comp : MapSequence.fromMap(myNodePointersToComponents).values()) { comp.dispose(); } for (EditorComponent component : myEditorComponents) { component.removeDisposeListener(myDisposeListener); } SModelRepository.getInstance().removeModelRepositoryListener(myRepositoryListener); for (SModel modelDescriptor : SetSequence.fromSetWithValues(new HashSet<SModel>(), myListenedModels)) { removeModelListener(modelDescriptor); } super.doDispose(); }
public void checkNode( final SNode node, LanguageErrorsComponent component, final IOperationContext operationContext, IScope scope) { if (operationContext == null) { return; } if (SNodeUtil.getMetaLevel(node) != 0) { return; } SNode concept = SNodeOperations.getConceptDeclaration(node); for (SReference ref : SNodeOperations.getReferences(node)) { SNode target = SLinkOperations.getTargetNode(ref); SNode ld = SLinkOperations.findLinkDeclaration(ref); // don't check unresolved and broken references, they should already have an error message if ((target == null) || ld == null) { continue; } component.addDependency(target); component.addDependency(ld); component.addDependency(node); component.addDependency(SNodeOperations.getParent(node)); for (SNode c : SNodeOperations.getChildren(node)) { component.addDependency(c); } String linkRole = SModelUtil.getGenuineLinkRole(ld); final SNode linkTarget = SLinkOperations.getTarget(ld, "target", false); final INodeReferentSearchScopeProvider scopeProvider = ModelConstraintsUtil.getSearchScopeProvider(concept, linkRole); SearchScopeStatus searchScopeStatus = component.runCheckingAction( new _FunctionTypes._return_P0_E0<SearchScopeStatus>() { public SearchScopeStatus invoke() { return ModelConstraintsUtil.createSearchScope( scopeProvider, SNodeOperations.getModel(node), SNodeOperations.getParent(node), node, linkTarget, operationContext); } }); if (searchScopeStatus.isError()) { component.addError( node, searchScopeStatus.getMessage(), (SNode) null, new ReferenceMessageTarget(SLinkOperations.getRole(ref))); } else if (!(searchScopeStatus.isDefault() || searchScopeStatus.getSearchScope().isInScope(target))) { String name = target.getName(); component.addError( node, "reference" + ((name == null ? "" : " " + name)) + " (" + SLinkOperations.getRole(ref) + ") is out of search scope", searchScopeStatus.getReferenceValidatorNode(), new ReferenceMessageTarget(SLinkOperations.getRole(ref))); } } }
public Set<EditorMessage> doCreateMessages( SNode node, List<SModelEvent> list, boolean wasCheckedOnce, EditorContext editorContext) { myMessagesChanged = false; EditorComponent editorComponent = (EditorComponent) editorContext.getEditorComponent(); SNode sNode = editorComponent.getEditedNode(); SNodeReference sNodePointer = editorComponent.getEditedNodePointer(); Set<EditorMessage> result = SetSequence.fromSet(new HashSet<EditorMessage>()); if (sNode == null) { if (LOG.isEnabledFor(Priority.ERROR)) { LOG.error("edited node is null"); } return result; } if (sNodePointer == null) { if (LOG.isEnabledFor(Priority.ERROR)) { LOG.error("edited NodePointer is null"); } return result; } SModel descriptor = SNodeOperations.getModel(sNode); if (descriptor == null) { // descriptor is null for a replaced model // after model is replaced but before it is disposed (this can happen asyncronously) return result; } LanguageErrorsComponent errorsComponent = MapSequence.fromMap(myNodePointersToComponents) .get(new SNodePointer(SNodeOperations.getContainingRoot(sNode))); if (errorsComponent == null) { errorsComponent = new LanguageErrorsComponent(sNode); MapSequence.fromMap(myNodePointersToComponents).put(sNodePointer, errorsComponent); } if (!(editorComponent instanceof InspectorEditorComponent) && !(SetSequence.fromSet(myEditorComponents).contains(editorComponent))) { SetSequence.fromSet(myEditorComponents).addElement(editorComponent); editorComponent.addDisposeListener(myDisposeListener); } addModelListener(descriptor); if (!(wasCheckedOnce)) { errorsComponent.clear(); } boolean changed = false; TypeCheckingContext typecheckingContext = editorComponent.getTypeCheckingContext(); try { if (typecheckingContext != null) { typecheckingContext.setIsNonTypesystemComputation(); } changed = errorsComponent.check(node, myRules, editorContext.getOperationContext()); } finally { if (typecheckingContext != null) { typecheckingContext.resetIsNonTypesystemComputation(); } } myMessagesChanged = changed; for (IErrorReporter errorReporter : errorsComponent.getErrors()) { MessageStatus status = errorReporter.getMessageStatus(); String errorString = errorReporter.reportError(); HighlighterMessage message = HighlightUtil.createHighlighterMessage( errorReporter.getSNode(), NameUtil.capitalize(status.getPresentation()) + ": " + errorString, errorReporter, LanguageEditorChecker.this, editorContext); SetSequence.fromSet(result).addElement(message); } return result; }