/// <summary>
/// Ensures that all elements have a Guid
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
ModelElement element = (ModelElement)obj;
if (UpdateGuid)
{
// Side effect : creates a new Guid if it is empty
// ReSharper disable once UnusedVariable
string guid = element.Guid;
}
// Make sure that the update information is consistent
if (!String.IsNullOrEmpty(element.Guid))
{
if (element.Updates != null)
{
element.SetUpdateInformation(element.Updates);
}
}
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null && ConvertObsoleteFile)
{
UpdateExpressionable(expressionable);
}
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>
/// Ensures that all elements have a new Guid
/// </summary>
/// <param name="obj"></param>
/// <param name="visitSubNodes"></param>
public override void visit(BaseModelElement obj, bool visitSubNodes)
{
ModelElement element = (ModelElement)obj;
// Side effect : creates a new Guid if it is empty
element.setGuid(null);
// ReSharper disable once UnusedVariable
string guid = element.Guid;
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);
}
/// <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);
}
/// <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)
{
RefactorIExpressionable(null, expressionable);
}
base.visit(obj, visitSubNodes);
}
protected void CheckNaming(object sender, EventArgs e)
{
BaseModelElement modelElement = Model as BaseModelElement;
if (modelElement != null)
{
ApplyNamingConventionsOperation naming = new ApplyNamingConventionsOperation(modelElement);
naming.ExecuteUsingProgressDialog(GuiUtils.MdiWindow, "Refactoring model according to naming conventions", true);
BuildOrRefreshSubNodes(modelElement);
}
}
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);
}
protected override void OnClick(EventArgs e)
{
BaseModelElement model = null;
if (Selected != null)
{
model = Selected.Instance as ModelElement;
}
EfsSystem.Instance.Context.HandleChangeEvent(model, Context.ChangeKind.ModelChange);
base.OnClick(e);
}
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>
/// Constructor
/// </summary>
/// <param name="model"></param>
public CheckNamingVisitor(BaseModelElement model)
{
DataDictionary.Generated.Namable namable = model as DataDictionary.Generated.Namable;
if (namable != null)
{
visit(namable);
}
else
{
visit(model);
}
}
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);
}
/// <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);
}
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 (Options.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 override void visit(BaseModelElement obj, bool visitSubNodes)
{
IExpressionable expressionable = obj as IExpressionable;
if (expressionable != null)
{
// Perform search and replace on ExpressionText
if (obj.ExpressionText.IndexOf(SearchString) >= 0)
{
obj.ExpressionText = obj.ExpressionText.Replace(SearchString, ReplaceString);
}
}
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);
}
}
/// <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)
{
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);
}
/// <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)
{
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);
}
/// <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)
{
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);
}
/// <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)
{
checkUsage(obj as ModelElement);
base.visit(obj, visitSubNodes);
}
/// <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 ApplyNamingConventionsOperation(BaseModelElement model)
{
_model = model;
}
