/// <summary> /// Refactors all IExpressionables /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionable = obj as IExpressionable; if (expressionable != null) { Compiler.RefactorIExpressionable(null, expressionable); } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { ModelElement element = (ModelElement) obj; if (AutomaticallyGenerateGuid) { // Side effect : creates the guid of the element // ReSharper disable once UnusedVariable string guid = element.Guid; } base.visit(obj, visitSubNodes); }
/// <summary> /// Walk through all elements /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionable = obj as IExpressionable; if (expressionable != null) { ConsiderInterpreterTreeNode(expressionable.Tree); } ITypedElement element = obj as ITypedElement; if (element != null) { ConsiderTypeOfElement(element); } Function function = obj as Function; if (function != null) { Type current = function.ReturnType; while (current != null) { if (current == Model && function != Model) { Usages.Add(new Usage(Model, function, Usage.ModeEnum.Type)); } current = EnclosingFinder<Type>.find(current); } } /* searching for the implementation of interfaces */ Structure structure = obj as Structure; Structure modelStructure = Model as Structure; if (structure != null && modelStructure != null && structure != modelStructure) { if (modelStructure.IsAbstract && structure.ImplementedStructures.Contains(modelStructure)) { Usages.Add(new Usage(Model, structure, Usage.ModeEnum.Interface)); } } /* searching for the redefinition of structure elements */ StructureElement currentStructureElement = Model as StructureElement; StructureElement parameterStructureElement = obj as StructureElement; if (currentStructureElement != null && parameterStructureElement != null) { Structure enclosingStructure = currentStructureElement.Enclosing as Structure; Structure enclosingParameterStructure = parameterStructureElement.Enclosing as Structure; if (enclosingStructure != null && enclosingParameterStructure != null && enclosingParameterStructure.IsAbstract && enclosingStructure.StructureElementIsInherited(currentStructureElement) && enclosingStructure.InterfaceIsInherited(enclosingParameterStructure)) { if (currentStructureElement.Name == parameterStructureElement.Name && currentStructureElement.Type == parameterStructureElement.Type) { Usages.Add(new Usage(currentStructureElement, parameterStructureElement, Usage.ModeEnum.Redefines)); } } } base.visit(obj, visitSubNodes); }
/// <summary> /// PropagatesDependancy all elements /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { if (obj.CacheDependancy != null) { BrowsedElements = new HashSet<Utils.ModelElement> {obj}; HashSet<Utils.ModelElement> dependingElements = obj.CacheDependancy; obj.CacheDependancy = null; foreach (Utils.ModelElement depending in dependingElements) { object current = depending; while (current != null) { Utils.ModelElement currentElement = current as Utils.ModelElement; if (currentElement != null) { PropagatesDependancy(currentElement, obj); } IEnclosed enclosed = current as IEnclosed; if (enclosed != null) { current = enclosed.Enclosing; } else { current = null; } } } } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionnable = obj as IExpressionable; if (expressionnable != null) { // In case of rebuild, cleans the previously constructed tree if (CurrentCompile.Rebuild) { expressionnable.CleanCompilation(); } // Ensures that the expressionable is compiled expressionnable.Compile(); } ITypedElement typedElement = obj as ITypedElement; if (typedElement != null) { // Ensures that the type of the corresponding element is cached Type type = typedElement.Type; } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { ModelElement element = (ModelElement) obj; string guid = element.Guid; if (guid != null) { ModelElement cachedElement; if (_dictionary.TryGetValue(guid, out cachedElement)) { if (cachedElement != null && element != cachedElement) { throw new Exception("Model element collision found"); } } else { _dictionary[element.Guid] = element; } } base.visit(obj, visitSubNodes); }
public virtual void visit(BaseModelElement obj, bool visitSubNodes) { visit ((IXmlBBase)obj, false); if (visitSubNodes){ IXmlBBase[] Subs = acceptor.subElements((IXmlBBase)obj); if (Subs != null){ for (int i=0; i<Subs.Length; i++) { dispatch(Subs[i], true); } // If } // If } }
/// <summary> /// Actually counts the messages /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { Count(obj); base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IFinder finder = obj as IFinder; if (finder != null) { FinderRepository.INSTANCE.UnRegister(finder); } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { checkUsage(obj as ModelElement); base.visit(obj, visitSubNodes); }
/// <summary> /// Ensure that empty comments are not stored in the XML file /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { ICommentable commentable = obj as ICommentable; if (commentable != null) { if (commentable.Comment == "") { commentable.Comment = null; } } base.visit(obj, visitSubNodes); }
/// <summary> /// Override for visiting a model element. If the model element is not a namespace, /// but its direct enclosing is a namespace, the element is imported and the visitor does /// not go further down the subnodes. /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { ModelElement element = obj as ModelElement; if (element != null && !(element is NameSpace)) { element.Merge(); } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { checkComment(obj as ICommentable); ModelElement model = obj as ModelElement; if (model != null) { checkUpdate(model); } base.visit(obj, visitSubNodes); }
/// <summary> /// Clears the cache dependancy when a full rebuilt is asked /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { // Clear the update information, to be built later ModelElement modelElement = obj as ModelElement; if (modelElement != null) { modelElement.UpdatedBy.Clear(); } if (Options.Rebuild) { obj.CacheDependancy = null; } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { RefactorIExpressionable(NameSpace, obj as IExpressionable); RefactorTypedElement(NameSpace, obj as ITypedElement); base.visit(obj, visitSubNodes); }
/// <summary> /// Actually counts /// </summary> /// <param name="obj"></param> private void Count(BaseModelElement obj) { foreach (ElementLog log in obj.Messages) { switch (log.Level) { case ElementLog.LevelEnum.Error: Error += 1; break; case ElementLog.LevelEnum.Warning: Warning += 1; break; case ElementLog.LevelEnum.Info: Info += 1; break; } } }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionable = obj as IExpressionable; if (expressionable != null) { try { RelocateTree refactorer = new RelocateTree(BaseLocation); refactorer.PerformUpdate(expressionable); } catch (Exception e) { obj.AddWarning("Cannot refactor this element, reason = " + e.Message); } } base.visit(obj, visitSubNodes); }
public virtual void visit(BaseModelElement obj) { visit(obj, true); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionable = obj as IExpressionable; if (expressionable != null) { // In case of rebuild, cleans the previously constructed tree if (CurrentCompile.Rebuild) { expressionable.CleanCompilation(); } // Ensures that the expressionable is compiled expressionable.Compile(); Structure structure = expressionable as Structure; if (structure != null) { if (structure != structure.UnifiedStructure) { visit(structure.UnifiedStructure, visitSubNodes); } } StateMachine stateMachine = expressionable as StateMachine; if (stateMachine != null) { if (stateMachine != stateMachine.UnifiedStateMachine) { visit(stateMachine.UnifiedStateMachine, visitSubNodes); } } } ITypedElement typedElement = obj as ITypedElement; if (typedElement != null) { // Ensures that the type of the corresponding element is cached Type type = typedElement.Type; } Function function = obj as Function; if (function != null) { Type returnType = function.ReturnType; } base.visit(obj, visitSubNodes); }
public void copyTo(BaseModelElement other) { other.aGuid = aGuid; other.aUpdates = aUpdates; other.aIsRemoved = aIsRemoved; }
/// <summary> /// Cleans up the declared elements dictionaries /// </summary> /// <param name="obj"></param> /// <param name="visitSubNodes"></param> public override void visit(BaseModelElement obj, bool visitSubNodes) { ModelElement modelElement = obj as ModelElement; if (modelElement != null) { if (modelElement.getUpdates() != null) { // find the model element updated by obj and add to its list of updates ModelElement baseElement = GuidCache.Instance.GetModel(modelElement.getUpdates()); if (baseElement != null) { baseElement.UpdatedBy.Add(modelElement); } base.visit(obj, visitSubNodes); } } }
public override void visit(BaseModelElement obj, bool visitSubNodes) { ModelElement element = (ModelElement) obj; if (element.Messages.Count > 0) { List<ElementLog> messages = new List<ElementLog>(); messages.AddRange(element.Messages); Markings[element] = messages; } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { IExpressionable expressionnable = obj as IExpressionable; if (expressionnable != null) { Function enclosingFunction = EnclosingFinder<Function>.find(obj, true); if (enclosingFunction != null) { // The value of the function depends on this. TheReferenceVisitor.UpdateReferences(enclosingFunction, expressionnable.Tree); } } base.visit(obj, visitSubNodes); }
public override void visit(BaseModelElement obj, bool visitSubNodes) { foreach (ElementLog log in obj.Messages) { if (log.Level == ElementLog.LevelEnum.Error) { ErrorMessageFound = log; break; } } if (ErrorMessageFound == null) { base.visit(obj, visitSubNodes); } }
public override void visit(BaseModelElement obj, bool visitSubNodes) { foreach (ElementLog log in obj.Messages) { if (log.Level == ElementLog.LevelEnum.Error) { ErrorsFound.Add(log); } } base.visit(obj, visitSubNodes); }