public void RemoveElement(bool join = false) { _primitives.RemoveAll(obj => obj.Container != null); if (Connectors.RemoveAll(obj => true) > 0) { DisconnectSiblings(); RemovePowerLines(); } if (Join.Any()) { if (!join) { foreach (var j in Join) { j.RemoveElement(true); } } Join.Clear(); } Variables.Clear(); OverrideFunction = false; Type = ElementType.None; }
/// <summary> /// Dispose the resources /// </summary> public override void Dispose() { Task.Run(() => { ProgramDeclaration = null; if (EntryPointInstance != null) { EntryPointInstance = null; } if (Variables != null) { foreach (var variable in Variables) { var value = variable.Value as IDisposable; if (value != null) { value.Dispose(); } } Variables.Clear(); } Variables = null; if (Classes != null) { Classes.Clear(); } Classes = null; FreeWaiter(); FreeStepIntoOverOutWaiter(); }); }
public void LoadDataFromNsi(IEnumerable <string> lines) { Variables.Clear(); var filteredLines = lines.Where(x => x.ToLower().Contains("!define ")); var defineLength = "!define ".Length; foreach (var line in filteredLines) { var temp = line.Remove(0, defineLength).Trim(); if (line.ToLower().Contains("\"")) { var name = temp.Substring(0, temp.IndexOf(' ')); var value = temp.Replace(name, "").Replace("\"", "").Trim(); Variables.Add(new VariableModel { VariableName = name, VariableValue = value, UserDefined = true }); } else { Variables.Add(new VariableModel { VariableName = temp, VariableValue = null, UserDefined = false }); } } }
///-------------------------------------------------------------------------------- /// <summary>This method gets the updated content for the template.</summary> /// /// <param name="parentModelContext">The parent model context from which to generate code.</param> /// /// <returns>A string representing the generated code for the template.</returns> ///-------------------------------------------------------------------------------- public string GetContent(IDomainEnterpriseObject parentModelContext) { try { ContentCodeBuilder.Clear(); if (IsWatchTemplate == false) { // clear parameters and variables if not passed in for temporary watch templates Parameters.Clear(); Variables.Clear(); } if (ContentAST == null && TemplateContent != String.Empty) { ParseContent(Solution.IsSampleMode); } if (ContentAST != null && ContentAST.ChildNodes.Count > 0) { ContentAST.InterpretNode(InterpreterTypeCode.Content, Solution, this, GetTemplateModelContext(parentModelContext), null); } ContentCode = ContentCodeBuilder.ToString() + MessageBuilder.ToString(); return(ContentCode); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { HasErrors = true; Solution.ShowIssue(ex.Message + ex.StackTrace, DisplayValues.Exception_CodeGenerationTitle, Solution.IsSampleMode); } return(null); }
///-------------------------------------------------------------------------------- /// <summary>This method generates the associated output path for the template.</summary> /// /// <param name="parentModelContext">The parent model context from which to generate code.</param> /// /// <returns>A string representing the generated code for the template.</returns> ///-------------------------------------------------------------------------------- public string GenerateOutput(IDomainEnterpriseObject parentModelContext) { try { MessageBuilder.Clear(); OutputCodeBuilder.Clear(); Parameters.Clear(); Variables.Clear(); if (OutputAST == null) { ParseOutput(Solution.IsSampleMode); } IDomainEnterpriseObject context = GetTemplateModelContext(parentModelContext); if (OutputAST != null && OutputAST.ChildNodes.Count > 0) { OutputAST.InterpretNode(InterpreterTypeCode.Output, Solution, this, context, null); OutputCode = OutputCodeBuilder.ToString() + MessageBuilder.ToString(); } return(OutputCode); } catch (ApplicationAbortException) { throw; } catch (System.Exception ex) { HasErrors = true; Solution.ShowIssue(ex.Message + ex.StackTrace, DisplayValues.Exception_CodeGenerationTitle, Solution.IsSampleMode); } return(null); }
public void Start() { IsReady = false; try { _runbookNameCache.Clear(); Runbooks.Clear(); Credentials.Clear(); Schedules.Clear(); Variables.Clear(); Modules.Clear(); Connections.Clear(); Tags.Clear(); Service.Load(); foreach (var rb in Runbooks) { _runbookNameCache.Add((rb.Tag as RunbookModelProxy).RunbookName); } Execute.OnUIThread(() => _statusManager.SetText("")); } catch (NotSupportedException) { // Ignore for now... } }
private void Reload() { var dtReader = new DataTableReader(testCaseCollectionManager.Scope.Content); //Reset the state of the DataTable //Remove the Sort Order or you'll be in troubles when loading the datatable TestCases.DefaultView.Sort = String.Empty; TestCases.Rows.Clear(); TestCases.Columns.Clear(); TestCases.RejectChanges(); //Load it TestCases.Load(dtReader, LoadOption.PreserveChanges); OnPropertyChanged("TestCases"); //Take care of variables Variables.Clear(); foreach (var v in testCaseCollectionManager.Scope.Variables) { Variables.Add(v); } if (VariableSelectedIndex < 0 && Variables.Count > 0) { VariableSelectedIndex = 0; } }
public DataTable GetValues(string SortingType, string Format) { DataTable table = new DataTable(); table.Columns.Add("Переменная"); table.Columns.Add("Значение"); string otbor = String.Format("\"{0}{1}\"", Format, SortingType); Answer answer = Database.SendGetAnswer(String.Format("USE {0}", this.DataBaseName), String.Format("VALUES FULL {0}", otbor)); if (answer.Info != Inf.OK) { answer.ShowMessage(); return(table); } Variables.Clear(); AnswerData data = answer.GetSerializedData(new string[] { "D| = ", "L|, " }); foreach (string val in data.GetEnumerable()) { Value var = new Value(val, data[val].GetEnumerable().ToList()); if (SortingType == "" && Format == "") { Variables.Add(var); } table.Rows.Add(new object[] { val, var }); } return(table); }
public void FromString(string text) { Variables.Clear(); text.Deserialize() .ApplySorting() .ForEach(Variables.Add); }
private static void Exit_Ini() { if (varsIni != null) { varsIni.Clear(); varsIni = null; } }
private static void Exit_Args() { if (varsArgs != null) { varsArgs.Clear(); varsArgs = null; } }
public void LoadVariablesFromFile(string fileName) { var lines = new List <string>(); if (File.Exists(fileName) == false) { return; // nothing to do. } using (var fs = new FileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)) using (var sr = new StreamReader(fs, Encoding.Default)) { while (!sr.EndOfStream) { lines.Add(sr.ReadLine()); } } Variables.Clear(); LoadedVariableFile = fileName; if (lines.Count > 0) { var headers = lines.First().ToLower().Split(','); for (var i = 1; i < lines.Count; i++) { var data = lines[i].ToLower().Split(','); var type = "unknown"; var name = "unknown"; for (var eIndex = 0; eIndex < data.Length && eIndex < headers.Length; eIndex++) { switch (headers[eIndex]) { case "type": type = data[eIndex]; break; case "name": name = data[eIndex]; break; default: throw new InvalidOperationException("Invalid parse column " + headers[eIndex]); } } Variables.Add(type, name); //VariableGrid.Items.Refresh(); } ConfigHelper.Config.DefaultCSVPath = fileName; // _dispatcher.Invoke(() => //{ //}); PropertyChanged(this, new PropertyChangedEventArgs(nameof(Variables))); PropertyChanged(this, new PropertyChangedEventArgs(nameof(LoadedVariableFile))); } }
public StyleSheet Refresh() { Rules.Clear(); m_ResolvedSheet = null; Variables.Clear(); ParentToChildren.Clear(); ChildToParent.Clear(); return(ResolvedSheet); }
/// <summary> /// Sets the patterns describing the variables that are assigned a new value. /// </summary> /// <param name="variables">The patterns describing the variables.</param> /// <returns>The current pattern.</returns> public AssignmentStatementPattern <TInstruction> WithVariables(params Pattern <IVariable>[] variables) { Variables.Clear(); foreach (var variable in variables) { Variables.Add(variable); } return(this); }
/// <summary> /// Indicates the pattern should match on instances with the provided number of variables on the left hand side. /// </summary> /// <param name="variablesCount">The number of variables the assignment statement should have.</param> /// <returns>The current pattern.</returns> public AssignmentStatementPattern <TInstruction> WithVariables(int variablesCount) { Variables.Clear(); for (int i = 0; i < variablesCount; i++) { Variables.Add(Pattern.Any <IVariable>()); } return(this); }
///-------------------------------------------------------------------------------- /// <summary>Interpret this node to produce content.</summary> /// /// <param name="solutionContext">The associated solution.</param> /// <param name="templateContext">The associated template.</param> /// <param name="modelContext">The associated model context.</param> /// <param name="appendToTemplateContext">Flag to append content.</param> /// <param name="parameters">Template parameters.</param> ///-------------------------------------------------------------------------------- public void GenerateContent(Solution solutionContext, ITemplate templateContext, IDomainEnterpriseObject modelContext, bool appendToTemplateContext, NameObjectCollection parameters) { ModelContextStack = null; PopCount = 0; if (modelContext is Project) { BusinessConfiguration.CurrentProject = modelContext as Project; } PushModelContext(modelContext); MessageBuilder.Clear(); ContentCodeBuilder.Clear(); Parameters.Clear(); Variables.Clear(); CurrentTabIndent = templateContext.CurrentTabIndent; if (ContentAST == null && TemplateContent != String.Empty) { ParseContent(Solution.IsSampleMode); } if (Solution.UseTemplateCache == true && Solution.IsSampleMode == false && String.IsNullOrEmpty(TemplateOutput) && !String.IsNullOrEmpty(TemplateContent) && modelContext != null && CachedContent[modelContext.ID.ToString()] != null) { // use cached content solutionContext.TemplatesExecuted++; solutionContext.CachedTemplatesExecuted++; ContentCodeBuilder.Append(CachedContent[modelContext.ID.ToString()] as String); } else { if (ContentAST != null) { ContentAST.InterpretNode(InterpreterTypeCode.Content, solutionContext, this, modelContext, parameters); } else { ContentCodeBuilder.Append("<" + TemplateName + ">"); } } if (Solution.UseTemplateCache == true && Solution.IsSampleMode == false && String.IsNullOrEmpty(TemplateOutput)) { CachedContent[modelContext.ID.ToString()] = null; // only cache smaller content that has no parameters or config settings if (Parameters.Count == 0 && HasRelativeSettings == false && ContentCodeBuilder.Length <= Solution.TemplateCacheMaxContentSize) { CachedContent[modelContext.ID.ToString()] = ContentCodeBuilder.ToString(); } } if (appendToTemplateContext == true) { templateContext.ContentCodeBuilder.Append(ContentCodeBuilder.ToString()); } ModelContextStack = null; PopCount = 0; }
/// <summary> /// Destroys the simulation. /// </summary> protected virtual void Unsetup() { // Clear all parameters EntityBehaviors.Clear(); EntityBehaviors = null; EntityParameters.Clear(); EntityParameters = null; // Clear all nodes Variables.Clear(); Variables = null; }
internal void Clear() { Variables.Clear(); Subroutines.Clear(); Labels.Clear(); Includes.Clear(); Imports.Clear(); Map.Clear(); Summary.Clear(); MainName = ""; MainPath = ""; }
public void Reduce(Func <Statement, bool> filter) { lock (_lock) { (Body as SuiteStatement)?.FilterStatements(filter); _attributes?.Clear(); Variables?.Clear(); CommentLocations = Array.Empty <SourceLocation>(); // DO keep NewLineLocations as they are required // to calculate node positions for navigation; base.Clear(); } }
private void UpdateVariablesList() { foreach (VariableViewModel model in Variables) { model.Dispose(); } Variables.Clear(); Variables.Add(new VariableViewModel()); foreach (string name in _globalVariables.VariableNames) { Variables.Add(new VariableViewModel(name)); } }
private void UpdateVariablees() { var NoOfVariables = _functionDefinition.Function.getArgumentsNumber(); if (NoOfVariables != Variables.Count()) { Variables.Clear(); for (int i = 0; i < NoOfVariables; i++) { Variables.Add(new Variable { VariableName = _functionDefinition.Function.getArgument(i).getArgumentName(), Value = 0 }); } } }
private void UpdateVariables() { var variables = Interpreter.CurrentScope .Select(x => new VariableViewModel() { Name = x.Key, Value = x.Value?.Value, }) .ToArray(); CodeViewer.BeginInvoke(() => { Variables.Clear(); variables.For(Variables.Add); }); }
public void Test() { // adjust culture var cultureInfo = this.CultureInfo; this.CultureInfo = System.Globalization.CultureInfo.InvariantCulture; // test internal operators Test("0", 0.0); Test("+1", 1.0); Test("-1", -1.0); Test("1+1", 1 + 1.0); Test("1*2*3*4*5*6*7*8*9", 1 * 2 * 3 * 4 * 5 * 6 * 7 * 8 * 9.0); Test("1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1/(1+1))))))))))", 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1 / (1 + 1.0))))))))))); Test("((1+2)*(2+3)/(4+5))^0.123", Math.Pow((1 + 2) * (2 + 3) / (4 + 5.0), 0.123)); Test("10%", 0.1); Test("1e+3", 1000.0); // test simple variables Variables.Add("one", 1); Variables.Add("two", 2); Test("one + two", 3); Test("(two + two)^2", 16); Variables.Clear(); // test DataContext var dc = DataContext; var p = Person.CreateTestPerson(); DataContext = p; Test("Name", "Test Person"); Test("Name.Length * 2", p.Name.Length * 2); Test("Children.Count", p.Children.Count); Test("Children(2).Name", p.Children[2].Name); Test("ChildrenDct(\"Test Child 2\").Name", p.ChildrenDct["Test Child 2"].Name); Test("ChildrenDct.Count", p.ChildrenDct.Count); DataContext = dc; // test functions Logical.Test(this); MathTrig.Test(this); Text.Test(this); Statistical.Test(this); // restore culture this.CultureInfo = cultureInfo; }
public void Clear() { _schema = null; Path.Clear(); Variables.Clear(); Fragments.Clear(); UsedVariables.Clear(); UnusedVariables.Clear(); DeclaredVariables.Clear(); Names.Clear(); Types.Clear(); Directives.Clear(); OutputFields.Clear(); InputFields.Clear(); Errors.Clear(); IsInError = false; }
private void OpenCode(string file) { //Path.GetFileNameWithoutExtension(file); if (!IsAppend) { Methods.Clear(); Variables.Clear(); } GetMethods(file, isClassFileName); GetVariables(file, isClassFileName); string className = Path.GetFileNameWithoutExtension(file); LogStatus("C# file " + className + ".cs parsed succesfully", true); }
private void MergeVariables() { var list = new List <Variable>(); foreach (var kv in Variables) { list.Add(kv.Value); } list.Sort(MergedVariable.Compare); Variables.Clear(); var index = 0; var v = new MergedVariable(PLC, $"{ThreadName}--{index++}") { Communicator = Communicator }; foreach (var x in list) { if (!v.Merge(x)) { bool noMerge = !v.NeedMerge(x); if (noMerge) { Variables.Add(x); } if (!v.IsEmpty) { v.MergeAddress(); Variables.Add(v); } v = new MergedVariable(PLC, $"{ThreadName}--{index++}") { Communicator = Communicator }; } } if (!v.IsEmpty) { v.MergeAddress(); Variables.Add(v); } }
public override void ExecuteHotkey(int index) { base.ExecuteHotkey(index); switch (index) { case 0: ExecuteScriptCommand.Execute(null); break; case 1: StopScriptCommand.Execute(null); break; case 2: Variables.Clear(); break; } }
public virtual void Clear(bool RaiseChangedEvent) { if (RaiseChangedEvent) { ResourceID = 0; ResourceName = String.Empty; FullString = String.Empty; Variables.Clear(); Styles.Clear(); } else { resourceID = 0; resourceName = String.Empty; fullString = String.Empty; Variables.Clear(); Styles.Clear(); } }
public void Parse(IList <Token> tokens) { Counts[Scope.Global] = 0; Counts[Scope.Flag] = 0; Counts[Scope.Local] = 0; Counts[Scope.Temp] = 0; Counts[Scope.Const] = 0; Contexts.Clear(); Variables.Clear(); Scripts.Clear(); InitConstants(); InScript = false; Tokens = tokens; Index = 0; LineNumber = 0; LastToken = null; while (Index < Tokens.Count) { Token tok = Peek(); switch (tok.Type) { case TokenType.Keyword: Keyword(); break; case TokenType.Identifier: Identifier(); break; // Ignore EOL tokens entirely case TokenType.EOL: Consume(); LineNumber++; break; default: throw new ParseException($"Cannot start line with {tok}"); } } }
/// <summary> /// Dispose the resources /// </summary> public override void Dispose() { Task.Run(() => { if (Variables != null) { foreach (var variable in Variables) { var value = variable.Value as IDisposable; if (value != null) { value.Dispose(); } } Variables.Clear(); } Variables = null; MethodDeclaration = null; }); }