public DynamicFunction(string name, ParseNode node, Variables args, int minParameters = 0, int maxParameters = 0) { Node = node; Arguments = args; MinParameters = minParameters; MaxParameters = maxParameters; }
public NewtonSystem(QpProblem data, Variables initialPoint) { this.Q = data.Q; this.A = data.A; this.initialCholeskyFactor = this.Factorize(initialPoint); }
public override void FinalizeProject(Variables.Root variables) { base.FinalizeProject(variables); variables.Average(Key+"LinesAvg", Key+"LinesTotal", Key+"CodeFiles"); variables.Average(Key+"CharsAvg", Key+"CharsTotal", Key+"CodeFiles"); variables.Average(Key+"CharsPerLineAvg", Key+"CharsTotal", Key+"LinesTotal"); State state = variables.GetStateObject<State>(stateOwner); foreach(FileIntValue fi in state.MaxLines){ variables.AddToArray(Key+"LinesTop", GetFileObject(fi, variables)); } foreach(FileIntValue fi in state.MinLines.Reverse()){ variables.AddToArray(Key+"LinesBottom", GetFileObject(fi, variables)); } foreach(FileIntValue fi in state.MaxChars){ variables.AddToArray(Key+"CharsTop", GetFileObject(fi, variables)); } foreach(FileIntValue fi in state.MinChars.Reverse()){ variables.AddToArray(Key+"CharsBottom", GetFileObject(fi, variables)); } }
/// <summary> /// Constructor /// </summary> /// <param name="variable"></param> /// <param name="previousValue"></param> /// <param name="newValue"></param> public Change(Variables.IVariable variable, Values.IValue previousValue, Values.IValue newValue) { Variable = variable; PreviousValue = previousValue; NewValue = newValue; Applied = false; }
public QpProgressReport(QpTerminationCode status, int iterations, double meritFunction, Variables currentIterate) { this.solveStatus = status; this.iterations = iterations; this.currentIterate = currentIterate == null ? null : currentIterate.Clone(); this.meritFunction = meritFunction; }
public void Write(FieldsParser information, string formName) { Variables variables = new Variables(); SqlTransaction sqlTransaction = SqlConn.BeginTransaction(); try { MasterConnection.SP.Execute(SqlConn, sqlTransaction, information.Master, variables); foreach (FieldsGroupConnection detailConnection in DetailConnections) { foreach (FieldsParser.Fields fields in information.Details) { if (fields.NodeName == detailConnection.Name) { detailConnection.SP.Execute(SqlConn, sqlTransaction, fields, variables); } } } sqlTransaction.Commit(); } catch { sqlTransaction.Rollback(); throw; } }
private void ButtonGenerate_Click(object sender, EventArgs e) { List<Variables> vList = new List<Variables>(); for (int i = 0; i < DGVProperties.Rows.Count - 1; i++) { Variables v = new Variables(); v.Name = DGVProperties.Rows[i].Cells[0].Value.ToString(); v.SQLType = DGVProperties.Rows[i].Cells[1].Value.ToString(); if (v.SQLType != null && v.SQLType != "") v.CSharpType = SelectCSharpType(v.SQLType.ToLower()); if (DGVProperties.Rows[i].Cells[2].Value != null && DGVProperties.Rows[i].Cells[2].Value.ToString() != "") v.VariableSize = Convert.ToInt32(DGVProperties.Rows[i].Cells[2].Value.ToString()); else v.VariableSize = 0; v.AllowNulls = Convert.ToBoolean(DGVProperties.Rows[i].Cells[3].Value); vList.Add(v); } if (textBoxPath.Text.Length != 0 && textBoxPath.Text[textBoxPath.Text.Length - 1] != '\\') textBoxPath.Text += "\\"; CreateClass.WriteProperties(vList, _className, textBoxPath.Text); CreateClass.WriteData(vList, _className, textBoxPath.Text); CreateClass.WriteBusiness(vList, _className, textBoxPath.Text); CreateClass.WriteList(vList, _className, textBoxPath.Text); }
/// <summary> /// The edit. /// </summary> /// <param name="parentWindow"> /// The parent window. /// </param> /// <param name="variables"> /// The variables. /// </param> /// <param name="connections"> /// The connections. /// </param> /// <returns> /// The <see cref="bool"/>. /// </returns> public bool Edit(IWin32Window parentWindow, Variables variables, Connections connections) { string jsonString = string.Empty; var value = this.metaData.CustomPropertyCollection["Settings"].Value; if (value != null) { jsonString = value.ToString(); } List<InputColumnInfo> inputColumnInfos = new List<InputColumnInfo>(); foreach (IDTSInputColumn100 col in this.metaData.InputCollection[0].InputColumnCollection) { inputColumnInfos.Add( new InputColumnInfo() { ColumnName = col.Name, DataType = col.DataType, LineageId = col.LineageID }); } FillablePdfDestinationUIForm editor = new FillablePdfDestinationUIForm( jsonString, inputColumnInfos.ToArray()); editor.ShowDialog(parentWindow); if (editor.DialogResult == DialogResult.OK || editor.DialogResult == DialogResult.Yes) { this.metaData.CustomPropertyCollection["Settings"].Value = editor.OutputConfigJsonString; return true; } return false; }
public QpProgressReport DetermineProgress(Variables iterate, Residuals residuals, double mu, int count) { var code = QpTerminationCode.InProgress; double residualsNorm = residuals.InfinityNorm(); double phi = ComputeMeritFunction(residuals, residualsNorm); this.UpdateMeritFunctionHistory(phi, count); bool isMuSatisfied = (mu < Tolerance); bool isRnormSatisfied = (residualsNorm < Tolerance * this.dataInfinityNorm); if (isMuSatisfied && isRnormSatisfied) { code = QpTerminationCode.Success; } else if (count >= MaxIterations) { code = QpTerminationCode.MaxIterationsExceeded; } else if (count > 20 && phi >= 1e-8 && phi >= 1e4 * this.phiMinimumHistory[count - 1]) { code = QpTerminationCode.Infeasible; } else if (count >= 30 && this.phiMinimumHistory[count] >= .5 * this.phiMinimumHistory[count - 30]) { code = QpTerminationCode.Unknown; } return includeDetailedReport || code != QpTerminationCode.InProgress ? new QpProgressReport(code, count, phi, iterate.Clone()) : new QpProgressReport(code, count, phi, null); }
public void Constructor_DetectsAdjacentCyclicalReference() { using (TestHostContext hc = new TestHostContext(this)) { // Arrange. var copy = new Dictionary<string, string> { { "variable1", "1_$(variable2)" }, { "variable2", "2_$(variable3)" }, { "variable3", "3_$(variable2)" }, }; // Act. List<string> warnings; var variables = new Variables(hc, copy, new List<MaskHint>(), out warnings); // Assert. Assert.Equal(3, warnings.Count); Assert.True(warnings.Any(x => string.Equals(x, StringUtil.Loc("Variable0ContainsCyclicalReference", "variable1")))); Assert.True(warnings.Any(x => string.Equals(x, StringUtil.Loc("Variable0ContainsCyclicalReference", "variable2")))); Assert.True(warnings.Any(x => string.Equals(x, StringUtil.Loc("Variable0ContainsCyclicalReference", "variable3")))); Assert.Equal("1_$(variable2)", variables.Get("variable1")); Assert.Equal("2_$(variable3)", variables.Get("variable2")); Assert.Equal("3_$(variable2)", variables.Get("variable3")); } }
public void Constructor_AppliesMaskHints() { using (TestHostContext hc = new TestHostContext(this)) { // Arrange. var copy = new Dictionary<string, string> { { "MySecretName", "My secret value" }, { "MyPublicVariable", "My public value" }, }; var maskHints = new List<MaskHint> { new MaskHint() { Type = MaskType.Variable, Value = "MySecretName" }, }; List<string> warnings; var variables = new Variables(hc, copy, maskHints, out warnings); // Act. KeyValuePair<string, string>[] publicVariables = variables.Public.ToArray(); // Assert. Assert.Equal(0, warnings.Count); Assert.Equal(1, publicVariables.Length); Assert.Equal("MyPublicVariable", publicVariables[0].Key); Assert.Equal("My public value", publicVariables[0].Value); Assert.Equal("My secret value", variables.Get("MySecretName")); } }
protected virtual void ProcessFileContents(File file, Variables.Root variables) { string[] contents = file.Contents.Split('\n'); int lineCount = 0, charCount = 0, maxCharsPerLine = 0; foreach(string line in contents){ if (!line.Trim().Equals("{")){ ++lineCount; } if (line.Length > 0){ int realLength = ParseUtils.CountCharacters(line); charCount += realLength; maxCharsPerLine = Math.Max(maxCharsPerLine, realLength); } } variables.Increment(Key+"LinesTotal", lineCount); variables.Increment(Key+"CharsTotal", charCount); variables.Maximum(Key+"LinesMax", lineCount); variables.Maximum(Key+"CharsMax", charCount); variables.Maximum(Key+"CharsPerLineMax", maxCharsPerLine); State state = variables.GetStateObject<State>(stateOwner); FileIntValue fileLines = new FileIntValue(file, lineCount); state.MaxLines.Add(fileLines); state.MinLines.Add(fileLines); FileIntValue fileChars = new FileIntValue(file, charCount); state.MaxChars.Add(fileChars); state.MinChars.Add(fileChars); }
public ISolver<double> Factorize(Variables currentIterate, int iteration) { if (iteration == 0) { return this.initialCholeskyFactor; } return this.Factorize(currentIterate); }
public override void Process(File file, Variables.Root variables) { base.Process(file, variables); variables.Increment("fileTypeCode"); variables.Increment(Key+"CodeFiles"); ProcessFileContents(file, variables); }
public Residuals(QpProblem data, Variables iterate) { this.Q = data.Q; this.c = data.c; this.A = data.A; this.b = data.b; this.Initialise(); this.Update(iterate); }
static Script() { if (Vars == null) Vars = new Variables(); if (Environment.OSVersion.Platform == PlatformID.Unix) Environment.SetEnvironmentVariable("MONO_VISUAL_STYLES", "gtkplus"); Application.EnableVisualStyles(); }
private ISolver<double> Factorize(Variables currentIterate) { Vector<double> z = currentIterate.z; Vector<double> s = currentIterate.s; Matrix<double> sOverZ = this.matBuilder.SparseOfDiagonalVector(z.Count, z.Count, z.PointwiseDivide(s)); Matrix<double> Q_bar = this.Q + this.A.Multiply(sOverZ).TransposeAndMultiply(A); return Q_bar.Cholesky(); }
public override string Process(TemplateList list, Variables variables) { string processedText = text; int offset = 0; foreach(TemplateToken token in tokens){ offset = token.ReplaceToken(offset, list, variables, ref processedText); } return processedText; }
public string ProcessTemplate(string templateName, Variables variables) { Template template; if (templates.TryGetValue(templateName, out template)){ return template.Process(this, variables); } else{ throw new TemplateException(Lang.Get["TemplateErrorNotFound", templateName]); } }
public Variables GenerateInitialPoint(QpProblem problem, Vector<double> x) { Vector<double> z = Vector<double>.Build.Dense(problem.A.ColumnCount, 1); Vector<double> s = Vector<double>.Build.Dense(problem.A.ColumnCount, 1); Variables initialPoint = new Variables(x, z, s); this.startingResiduals = new Residuals(problem, initialPoint); this.startingEquations = new NewtonSystem(problem, initialPoint); return initialPoint; }
public Frame (Goal [] goals, Goal parent, BoundVariableSet boundVariables, Dictionary <string, Variable> variables) { this.goals = goals; this.boundVariables = boundVariables; this.HeadGoal = parent; this.variables = new Variables(variables); foreach (var goal in goals) { goal.Frame = this; } }
public bool Edit(IWin32Window parentWindow, Variables variables, Connections connections) { DialogResult dialogResult; try { MessageBox.Show(parentWindow, "The custom user interface is under construction in the release." + Environment.NewLine + "Please use the advanced editor for now.", NopConstants.COMPONENT_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error); } catch (Exception ex) { MessageBox.Show(parentWindow, ex.ToString(), NopConstants.COMPONENT_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error); } return false; }
public void Update(Variables newIterate) { Vector<double> x = newIterate.x; Vector<double> z = newIterate.z; Vector<double> s = newIterate.s; this.Q.Multiply(x, this.rd); this.rd.Add(this.c, this.rd); this.DualityGap = this.rd.DotProduct(x) - this.b.DotProduct(z); this.rd.Subtract(this.A * z, this.rd); s.Add(this.b, this.rp); this.rp.Subtract(A.TransposeThisAndMultiply(x), this.rp); s.PointwiseMultiply(z, this.rs); }
private TestHostContext CreateTestContext([CallerMemberName] String testName = "") { var hc = new TestHostContext(this, testName); List<string> warnings; _variables = new Variables( hostContext: hc, copy: new Dictionary<string, string>(), maskHints: new List<MaskHint>(), warnings: out warnings); _ec = new Mock<IExecutionContext>(); _ec.SetupAllProperties(); _ec.Setup(x => x.Variables).Returns(_variables); _stepsRunner = new StepsRunner(); _stepsRunner.Initialize(hc); return hc; }
public Variables ComputeStep(Variables currentIterate, Residuals residuals, ISolver<double> CholeskyFactor) { // Define shorter names Vector<double> z = currentIterate.z; Vector<double> s = currentIterate.s; Vector<double> rp = residuals.rp; Vector<double> rd = residuals.rd; Vector<double> rs = residuals.rs; Vector<double> r_bar = A * (rs - z.PointwiseMultiply(rp)).PointwiseDivide(s); Vector<double> c_bar = rd + r_bar; c_bar.Negate(c_bar); Vector<double> stepX = CholeskyFactor.Solve(c_bar); Vector<double> stepS = A.TransposeThisAndMultiply(stepX) - rp; Vector<double> stepZ = -(rs + z.PointwiseMultiply(stepS)).PointwiseDivide(s); return new Variables(stepX, stepZ, stepS); }
public bool Edit(IWin32Window parentWindow, Variables variables, Connections connections) { try { // Create UI form and display ReverseStringUIForm ui = new ReverseStringUIForm(_dtsComponentMetaData, _serviceProvider, connections); DialogResult result = ui.ShowDialog(parentWindow); // Set return value to represent DialogResult. This tells the // managed wrapper to persist any changes made // on the component input and/or output, or properties. if (result == DialogResult.OK) { return true; } } catch (Exception ex) { MessageBox.Show(ex.ToString()); } return false; }
public bool Edit(IWin32Window parentWindow, Variables variables, Connections connections) { DialogResult dialogResult; try { MessageBox.Show(parentWindow, "The custom user interface is under construction in the release." + Environment.NewLine + "Please use the advanced editor for now.", Constants.COMPONENT_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error); /*using (ObfuConfMainForm form = new ObfuConfMainForm()) { form.ObfuscationConfiguration = this.ComponentMetadataWrapper.GetTableConfiguration().Parent as ObfuscationConfiguration; dialogResult = form.ShowDialog(parentWindow); if (dialogResult == DialogResult.OK) return true; }*/ } catch (Exception ex) { MessageBox.Show(parentWindow, ex.ToString(), Constants.COMPONENT_NAME, MessageBoxButtons.OK, MessageBoxIcon.Error); } return false; }
public TestHostContext Setup([CallerMemberName] string name = "") { // Setup the host context. TestHostContext hc = new TestHostContext(this, name); // Create a random work path. var configStore = new Mock<IConfigurationStore>(); _workFolder = Path.Combine( Path.GetDirectoryName(Assembly.GetEntryAssembly().Location), $"_work_{Path.GetRandomFileName()}"); var settings = new AgentSettings() { WorkFolder = _workFolder, }; configStore.Setup(x => x.GetSettings()).Returns(settings); hc.SetSingleton<IConfigurationStore>(configStore.Object); // Setup the execution context. _ec = new Mock<IExecutionContext>(); List<string> warnings; _variables = new Variables(hc, new Dictionary<string, string>(), new List<MaskHint>(), out warnings); _variables.Set(Constants.Variables.System.CollectionId, CollectionId); _variables.Set(WellKnownDistributedTaskVariables.TFCollectionUrl, CollectionUrl); _variables.Set(Constants.Variables.System.DefinitionId, DefinitionId); _variables.Set(Constants.Variables.Build.DefinitionName, DefinitionName); _ec.Setup(x => x.Variables).Returns(_variables); // Setup the endpoint. _endpoint = new ServiceEndpoint() { Url = new Uri(EndpointUrl) }; // Setup the tracking manager. _trackingManager = new TrackingManager(); _trackingManager.Initialize(hc); return hc; }
public object CoerceValue(ISchema schema, GraphType type, object input, Variables variables = null) { if (type is NonNullGraphType) { var nonNull = type as NonNullGraphType; return CoerceValue(schema, schema.FindType(nonNull.Type), input, variables); } if (input == null) { return null; } var variable = input as Variable; if (variable != null) { return variables != null ? variables.ValueFor(variable.Name) : null; } if (type is ListGraphType) { var listType = type as ListGraphType; var listItemType = schema.FindType(listType.Type); var list = input as IEnumerable; return list != null && !(input is string) ? list.Map(item => CoerceValue(schema, listItemType, item, variables)).ToArray() : new[] { CoerceValue(schema, listItemType, input, variables) }; } if (type is ObjectGraphType || type is InputObjectGraphType) { var obj = new Dictionary<string, object>(); if (input is KeyValuePair<string, object>) { var kvp = (KeyValuePair<string, object>)input; input = new Dictionary<string, object> { { kvp.Key, kvp.Value } }; } var kvps = input as IEnumerable<KeyValuePair<string, object>>; if (kvps != null) { input = kvps.ToDictionary(kvp => kvp.Key, kvp => kvp.Value); } var dict = input as Dictionary<string, object>; if (dict == null) { return null; } type.Fields.Apply(field => { object inputValue; if (dict.TryGetValue(field.Name, out inputValue)) { var fieldValue = CoerceValue(schema, schema.FindType(field.Type), inputValue, variables); obj[field.Name] = fieldValue ?? field.DefaultValue; } }); return obj; } if (type is ScalarGraphType) { var scalarType = type as ScalarGraphType; return scalarType.Coerce(input); } return input; }
public async Task <WorkflowExecutionContext> InvokeAsync(Workflow workflow, IActivity startActivity = default, Variables arguments = default, CancellationToken cancellationToken = default) { workflow.Arguments = arguments ?? new Variables(); var workflowExecutionContext = new WorkflowExecutionContext(workflow); var isResuming = workflowExecutionContext.Workflow.Status == WorkflowStatus.Resuming; // If a start activity was provided, remove it from the blocking activities list. If not start activity was provided, pick the first one that has no inbound connections. if (startActivity != null) { workflow.BlockingActivities.Remove(startActivity); } else { startActivity = workflow.GetStartActivities().FirstOrDefault(); } if (!isResuming) { workflow.StartedAt = clock.GetCurrentInstant(); } workflowExecutionContext.Workflow.Status = WorkflowStatus.Executing; if (startActivity != null) { workflowExecutionContext.ScheduleActivity(startActivity); } // Keep executing activities as long as there are any scheduled. while (workflowExecutionContext.HasScheduledActivities) { var currentActivity = workflowExecutionContext.PopScheduledActivity(); var result = await ExecuteActivityAsync(workflowExecutionContext, currentActivity, isResuming, cancellationToken); if (result == null) { break; } await result.ExecuteAsync(this, workflowExecutionContext, cancellationToken); workflowExecutionContext.IsFirstPass = false; isResuming = false; } // Any other status than Halted means the workflow has ended (either because it reached the final activity, was aborted or has faulted). if (workflowExecutionContext.Workflow.Status != WorkflowStatus.Halted) { workflowExecutionContext.Finish(clock.GetCurrentInstant()); } else { // Persist workflow before executing the halted activities. await workflowStore.SaveAsync(workflow, cancellationToken); // Invoke Halted event on activity drivers that halted the workflow. while (workflowExecutionContext.HasScheduledHaltingActivities) { var currentActivity = workflowExecutionContext.PopScheduledHaltingActivity(); var result = await ExecuteActivityHaltedAsync(workflowExecutionContext, currentActivity, cancellationToken); await result.ExecuteAsync(this, workflowExecutionContext, cancellationToken); } } await workflowStore.SaveAsync(workflow, cancellationToken); return(workflowExecutionContext); }
/// <summary> /// Evaluates the function on a scalar argument. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement EvaluateScalar(string Argument, Variables Variables) { return(new StringValue(System.Net.WebUtility.UrlEncode(Argument))); }
private void CalcMomentary(List <Field> Fields, DateTime Now, ushort Raw) { Fields.Add(new Int32Field(this, Now, "Raw", Raw, FieldType.Momentary, FieldQoS.AutomaticReadout, typeof(Module).Namespace, 26)); if (this.exp is null && !string.IsNullOrEmpty(this.expression)) { this.exp = new Expression(this.expression); } if (this.exp != null) { Variables v = new Variables() { { "Raw", (double)Raw } }; object Value = this.exp.Evaluate(v); Field F; if (Value is double dbl) { F = new QuantityField(this, Now, this.fieldName, dbl, this.nrDecimals, this.unit, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is PhysicalQuantity qty) { F = new QuantityField(this, Now, this.fieldName, qty.Magnitude, this.nrDecimals, qty.Unit.ToString(), FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is bool b) { F = new BooleanField(this, Now, this.fieldName, b, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is DateTime DT) { F = new DateTimeField(this, Now, this.fieldName, DT, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is Duration D) { F = new DurationField(this, Now, this.fieldName, D, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is Enum E) { F = new EnumField(this, Now, this.fieldName, E, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is int i32) { if (string.IsNullOrEmpty(this.unit)) { F = new Int32Field(this, Now, this.fieldName, i32, FieldType.Momentary, FieldQoS.AutomaticReadout); } else { F = new QuantityField(this, Now, this.fieldName, i32, 0, this.unit, FieldType.Momentary, FieldQoS.AutomaticReadout); } } else if (Value is long i64) { if (string.IsNullOrEmpty(this.unit)) { F = new Int64Field(this, Now, this.fieldName, i64, FieldType.Momentary, FieldQoS.AutomaticReadout); } else { F = new QuantityField(this, Now, this.fieldName, i64, 0, this.unit, FieldType.Momentary, FieldQoS.AutomaticReadout); } } else if (Value is string s) { F = new StringField(this, Now, this.fieldName, s, FieldType.Momentary, FieldQoS.AutomaticReadout); } else if (Value is TimeSpan TS) { F = new TimeField(this, Now, this.fieldName, TS, FieldType.Momentary, FieldQoS.AutomaticReadout); } else { F = new StringField(this, Now, this.fieldName, Value.ToString(), FieldType.Momentary, FieldQoS.AutomaticReadout); } if (this.fieldName == "Value") { F.Module = typeof(Module).Namespace; F.StringIdSteps = new LocalizationStep[] { new LocalizationStep(13) }; } Fields.Add(F); } }
public static List<LogInfo> Set(EngineState s, CodeCommand cmd) { CodeInfo_Set info = cmd.Info.Cast<CodeInfo_Set>(); Variables.VarKeyType varType = Variables.DetectType(info.VarKey); if (varType == Variables.VarKeyType.None) { // Check Macro if (Regex.Match(info.VarKey, Macro.MacroNameRegex, RegexOptions.Compiled | RegexOptions.CultureInvariant).Success) // Macro Name Validation { string macroCommand = StringEscaper.Preprocess(s, info.VarValue); if (macroCommand.Equals("NIL", StringComparison.OrdinalIgnoreCase)) macroCommand = null; LogInfo log = s.Macro.SetMacro(info.VarKey, macroCommand, cmd.Section, info.Permanent, false); return new List<LogInfo>(1) { log }; } } // [WB082 Behavior] -> Enabled if s.CompatAllowSetModifyInterface == true // If PERMANENT was used but the key exists in interface command, the value will not be written to script.project but in interface. // Need to investigate where the logs are saved in this case. switch (info.Permanent) { case true: { // Check if interface contains VarKey List<LogInfo> logs = new List<LogInfo>(); if (Variables.DetectType(info.VarKey) != Variables.VarKeyType.Variable) goto case false; #region Set interface control's value (Compat) if (s.CompatAllowSetModifyInterface) { string varKey = Variables.TrimPercentMark(info.VarKey); string finalValue = StringEscaper.Preprocess(s, info.VarValue); Script sc = cmd.Section.Script; ScriptSection iface = sc.GetInterfaceSection(out _); if (iface == null) goto case false; (List<UIControl> uiCtrls, _) = UIParser.ParseStatements(iface.Lines, iface); UIControl uiCtrl = uiCtrls.Find(x => x.Key.Equals(varKey, StringComparison.OrdinalIgnoreCase)); if (uiCtrl == null) goto case false; bool valid = uiCtrl.SetValue(finalValue, false, out List<LogInfo> varLogs); logs.AddRange(varLogs); if (valid) { // Update uiCtrl into file uiCtrl.Update(); // Also update local variables logs.AddRange(Variables.SetVariable(s, info.VarKey, info.VarValue, false, false)); return logs; } } goto case false; #endregion } case false: default: return Variables.SetVariable(s, info.VarKey, info.VarValue, info.Global, info.Permanent); } }
/// <summary> /// Evaluates the function on a scalar argument. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement EvaluateScalar(Complex Argument, Variables Variables) { return(new ComplexNumber(Complex.Reciprocal(Complex.Tan(Argument)))); }
// Use this for initialization void Awake() { Variables = GameObject.FindGameObjectWithTag("UI").GetComponent <Variables>(); //This pulls the variables from the variables script. It's a handy way to call variables from objects without manualy telling unity where to look for the corisponding script every time a new scene loads. }
private void ExecuteDrawableFillRule(XmlElement element, Collection <IDrawable> drawables) { FillRule fillRule_ = Variables.GetValue <FillRule>(element, "fillRule"); drawables.Add(new DrawableFillRule(fillRule_)); }
private void ExecuteDrawableFontPointSize(XmlElement element, Collection <IDrawable> drawables) { double pointSize_ = Variables.GetValue <double>(element, "pointSize"); drawables.Add(new DrawableFontPointSize(pointSize_)); }
private void ExecuteDrawableFillOpacity(XmlElement element, Collection <IDrawable> drawables) { Percentage opacity_ = Variables.GetValue <Percentage>(element, "opacity"); drawables.Add(new DrawableFillOpacity(opacity_)); }
private void ExecuteDrawableFillPatternUrl(XmlElement element, Collection <IDrawable> drawables) { String url_ = Variables.GetValue <String>(element, "url"); drawables.Add(new DrawableFillPatternUrl(url_)); }
private void ExecuteDrawableClipUnits(XmlElement element, Collection <IDrawable> drawables) { ClipPathUnit units_ = Variables.GetValue <ClipPathUnit>(element, "units"); drawables.Add(new DrawableClipUnits(units_)); }
private void ExecuteDrawableTextKerning(XmlElement element, Collection <IDrawable> drawables) { double kerning_ = Variables.GetValue <double>(element, "kerning"); drawables.Add(new DrawableTextKerning(kerning_)); }
/// <summary> /// Enumerator that reorders a sequence of items. /// </summary> /// <param name="ItemEnumerator">Item enumerator</param> /// <param name="Variables">Current set of variables.</param> /// <param name="Order">Custom order.</param> public CustomOrderEnumerator(IResultSetEnumerator ItemEnumerator, Variables Variables, KeyValuePair <ScriptNode, bool>[] Order) { this.order = Order; this.items = ItemEnumerator; this.variables = Variables; }
private void ExecuteDrawableTextEncoding(XmlElement element, Collection <IDrawable> drawables) { Encoding encoding_ = Variables.GetValue <Encoding>(element, "encoding"); drawables.Add(new DrawableTextEncoding(encoding_)); }
private void ExecuteDrawableGravity(XmlElement element, Collection <IDrawable> drawables) { Gravity gravity_ = Variables.GetValue <Gravity>(element, "gravity"); drawables.Add(new DrawableGravity(gravity_)); }
/// <summary> /// Add Variable to request. /// </summary> /// <param name="name">Name of variable.</param> /// <param name="value">Value of variable.</param> /// <returns></returns> public IGraphQLRequest AddVariable(string name, object value) { Variables.Add(name, value); return(this); }
private void ExecuteDrawablePushClipPath(XmlElement element, Collection <IDrawable> drawables) { String clipPath_ = Variables.GetValue <String>(element, "clipPath"); drawables.Add(new DrawablePushClipPath(clipPath_)); }
/// <summary> /// Evaluates the function on a scalar argument. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement EvaluateScalar(double Argument, Variables Variables) { return(new DoubleNumber(1.0 / Math.Tan(Argument))); }
private void ExecuteDrawableSkewY(XmlElement element, Collection <IDrawable> drawables) { double angle_ = Variables.GetValue <double>(element, "angle"); drawables.Add(new DrawableSkewY(angle_)); }
/// <summary> /// Enumerator that limits the return set to a maximum number of records. /// </summary> /// <param name="ItemEnumerator">Item enumerator</param> /// <param name="Columns">Column definitions. Might be null if objects are to be returned.</param> /// <param name="Variables">Current set of variables.</param> public RecordEnumerator(IResultSetEnumerator ItemEnumerator, ScriptNode[] Columns, Variables Variables) { this.e = ItemEnumerator; this.columns = Columns; this.variables = Variables; this.count = this.columns?.Length ?? 0; }
private void ExecuteDrawableStrokeAntialias(XmlElement element, Collection <IDrawable> drawables) { Boolean isEnabled_ = Variables.GetValue <Boolean>(element, "isEnabled"); drawables.Add(new DrawableStrokeAntialias(isEnabled_)); }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement Evaluate(IElement Argument, Variables Variables) { throw new LoopDetectedException(Argument.AssociatedObjectValue); }
private void ExecuteDrawableStrokeColor(XmlElement element, Collection <IDrawable> drawables) { MagickColor color_ = Variables.GetValue <MagickColor>(element, "color"); drawables.Add(new DrawableStrokeColor(color_)); }
public virtual void testStartAfterActivityListenerInvocation() { RecorderExecutionListener.clear(); ProcessInstance instance = runtimeService.startProcessInstanceByKey("transitionListenerProcess", Variables.createVariables().putValue("listener", new RecorderExecutionListener())); Batch modificationBatch = runtimeService.createProcessInstanceModification(instance.Id).startTransition("flow2").executeAsync(); assertNotNull(modificationBatch); executeSeedAndBatchJobs(modificationBatch); // transition listener should have been invoked IList <RecorderExecutionListener.RecordedEvent> events = RecorderExecutionListener.RecordedEvents; assertEquals(1, events.Count); RecorderExecutionListener.RecordedEvent @event = events[0]; assertEquals("flow2", @event.TransitionId); RecorderExecutionListener.clear(); ActivityInstance updatedTree = runtimeService.getActivityInstance(instance.Id); assertNotNull(updatedTree); assertEquals(instance.Id, updatedTree.ProcessInstanceId); assertThat(updatedTree).hasStructure(describeActivityInstanceTree(instance.ProcessDefinitionId).activity("task1").activity("task2").done()); ExecutionTree executionTree = ExecutionTree.forExecution(instance.Id, processEngine); assertThat(executionTree).matches(describeExecutionTree(null).scope().child("task1").concurrent().noScope().up().child("task2").concurrent().noScope().done()); completeTasksInOrder("task1", "task2", "task2"); assertProcessEnded(instance.Id); }
private void ExecuteDrawableStrokeDashArray(XmlElement element, Collection <IDrawable> drawables) { Double[] dash_ = Variables.GetDoubleArray(element["dash"]); drawables.Add(new DrawableStrokeDashArray(dash_)); }
public Task <WorkflowExecutionContext> ResumeAsync(Workflow workflow, IActivity startActivity = default, Variables arguments = default, CancellationToken cancellationToken = default) { workflow.Status = WorkflowStatus.Resuming; return(InvokeAsync(workflow, startActivity, arguments, cancellationToken)); }
private void ExecuteDrawableStrokeDashOffset(XmlElement element, Collection <IDrawable> drawables) { double offset_ = Variables.GetValue <double>(element, "offset"); drawables.Add(new DrawableStrokeDashOffset(offset_)); }
public Variables GetVariableValues(ISchema schema, Variables variables, Inputs inputs) { variables.Apply(v => { object variableValue; if (inputs != null && inputs.TryGetValue(v.Name, out variableValue)) { v.Value = GetVariableValue(schema, v, variableValue); } else { v.Value = GetVariableValue(schema, v, v.DefaultValue); } }); return variables; }
/// <summary> /// Evaluates the function. /// </summary> /// <param name="Argument">Function argument.</param> /// <param name="Variables">Variables collection.</param> /// <returns>Function result.</returns> public override IElement Evaluate(IElement Argument, Variables Variables) { throw new SeeOtherException(Expression.ToString(Argument.AssociatedObjectValue)); }
private void ExecuteDrawableTextInterwordSpacing(XmlElement element, Collection <IDrawable> drawables) { double spacing_ = Variables.GetValue <double>(element, "spacing"); drawables.Add(new DrawableTextInterwordSpacing(spacing_)); }
private void ExecuteDrawableTextDirection(XmlElement element, Collection <IDrawable> drawables) { TextDirection direction_ = Variables.GetValue <TextDirection>(element, "direction"); drawables.Add(new DrawableTextDirection(direction_)); }