public override void EvaluateInternal(H holder, MemberInfo groupKey) { // вычисляем переменную из котрой следует получить значения CalculatedVariable <H, T, I> basedVar = (CalculatedVariable <H, T, I>)DependsOn.Single(); basedVar.Evaluate(holder, groupKey, LastMoniker); // для каждого периода времени вычисляем значение переменной foreach (var tp in Period.Periods.Select((t, i) => new TimeArg <I>(t, i, groupKey, Period.Name, this.Name))) { I next = Period.Periods.FirstOrDefault(p => Operator.GreaterThan(p, tp.T)); var subPeriod = basedVar.Period.Between(tp.T, next); List <T> result = Activator.CreateInstance <List <T> >(); Int32 c = 0; foreach (I s in subPeriod) { var ta = new TimeArg <I>(s, c++, groupKey, basedVar.Period.Name, basedVar.Name); result.Add((T)basedVar.Results[ta]); } Results.Add(tp, result); // если требуется вернуть значение переменной, то записываем результат в свойство // holder, это свойство будет содержить список значений всех переменных на момент времени t if (Readers.Any()) { ApplyValueForHolder(holder, tp); ExecuteAllReaders(tp); } } }
/// <summary> /// This finally will always run on the same thread as the last task that runs /// </summary> public ITask Finally(Action handler) { Guard.ArgumentNotNull(handler, "handler"); finallyHandler += handler; DependsOn?.Finally(handler); return(this); }
/// <summary> /// Catch runs right when the exception happens (on the same thread) /// Chain will be cancelled /// </summary> public ITask Catch(Action <Exception> handler) { Guard.ArgumentNotNull(handler, "handler"); faultHandler += e => { handler(e); return(false); }; DependsOn?.Catch(handler); return(this); }
public override void EvaluateInternal(H holder, MemberInfo groupKey) { // вычисляем переменную из котрой следует получить значения CalculatedVariable <H, T, I> basedVar = (CalculatedVariable <H, T, I>)DependsOn.Single(); // check basedVar.Period == this.Period; (они должны совпадать) basedVar.Evaluate(holder, groupKey, LastMoniker); var periods = Period.Periods.Select((t, i) => new TimeArg <I>(t, i, groupKey, Period.Name, this.Name)); if (Shift >= 0) { ShiftData(basedVar, periods, Shift); } else { var p2 = Period.Periods.Reverse().Select((t, i) => new TimeArg <I>(t, i, groupKey, Period.Name, this.Name)); ShiftData(basedVar, p2, -Shift); } foreach (var tp in periods) { if (Readers.Any()) { ApplyValueForHolder(holder, tp); ExecuteAllReaders(tp); } } }
public override void EvaluateInternal(H holder, MemberInfo groupKey) { // вычисляем переменную из котрой следует получить значения CalculatedVariable <H, T, I> basedVar = (CalculatedVariable <H, T, I>)DependsOn.Single(); // вычислять не требуется, т.к. переменная должна быть уже вычислена в более глубокой группе // для каждого периода времени вычисляем значение переменной foreach (var tp in Period.Periods.Select((t, i) => new TimeArg <I>(t, i, groupKey, Period.Name, this.Name))) { Dictionary <K, T> result = Activator.CreateInstance <Dictionary <K, T> >(); //foreach (var p in basedVar.Results.Where(pair => pair.Key.T == tp.T && pair.Key.ForMember.ParentMember == groupKey)) foreach (var p in basedVar.Results.Where(pair => Operator.Equal(pair.Key.T, tp.T) && pair.Key.ForGroupMember.Parents.Contains(groupKey))) { result.Add((K)p.Key.GroupKey, p.Value); } Results.Add(tp, result); // если требуется вернуть значение переменной, то записываем результат в свойство // holder, это свойство будет содержить список значений всех переменных на момент времени t if (Readers.Any()) { ApplyValueForHolder(holder, tp); ExecuteAllReaders(tp); } } }
/// <summary> /// Catch runs right when the exception happens (on the same threaD) /// Return true if you want the task to completely successfully /// </summary> public ITask Catch(Func <Exception, bool> handler) { Guard.ArgumentNotNull(handler, "handler"); CatchInternal(handler); DependsOn?.Catch(handler); return(this); }
/// <summary> /// Function to serialize this file into an XML element. /// </summary> /// <returns>An XML element containing the serialized contents of the file object.</returns> internal XElement Serialize() { var result = new XElement(EditorFileNode, new XAttribute(EditorFilePathAttr, FilePath), new XAttribute(EditorFilePlugInTypeAttr, PlugInType ?? string.Empty)); if (DependsOn.Count > 0) { // Serialize any dependencies. result.Add(new XElement(EditorDependenciesNodeRoot, DependsOn.Serialize())); } if (Attributes.Count == 0) { return(result); } // Add custom attributes. var root = new XElement(EditorFileCustomNodeRoot); foreach (KeyValuePair <string, string> attr in Attributes.Where(attr => !string.IsNullOrWhiteSpace(attr.Key))) { root.Add(new XElement(EditorFileCustomNode, new XAttribute(EditorCustomNameAttr, attr.Key), attr.Value)); } result.Add(root); return(result); }
/// <summary> /// Catch runs right when the exception happens (on the same threaD) /// Return true if you want the task to completely successfully /// </summary> public ITask Catch(Func <Exception, bool> handler) { Guard.ArgumentNotNull(handler, "handler"); faultHandler += handler; DependsOn?.Catch(handler); return(this); }
internal void SetFaultHandler(TaskBase handler) { Task.ContinueWith(t => handler.Start(t), Token, TaskContinuationOptions.OnlyOnFaulted, TaskManager.GetScheduler(handler.Affinity)); DependsOn?.SetFaultHandler(handler); }
/// <summary> /// Initializes a new instance of <see cref="ModuleInfo"/>. /// </summary> /// <param name="name">The module's name.</param> /// <param name="type">The module <see cref="Type"/>'s AssemblyQualifiedName.</param> /// <param name="dependsOn">The modules this instance depends on.</param> /// <exception cref="ArgumentNullException">An <see cref="ArgumentNullException"/> is thrown if <paramref name="dependsOn"/> is <see langword="null"/>.</exception> public ModuleInfo(string name, string type, params string[] dependsOn) { if (Type.GetType(type) == null) { throw new ArgumentNullException(nameof(type)); } if (string.IsNullOrWhiteSpace(name)) { throw new ArgumentNullException(nameof(name)); } if (dependsOn == null) { throw new ArgumentNullException(nameof(dependsOn)); } ModuleName = name; ModuleType = type; foreach (string dependency in dependsOn) { if (!DependsOn.Contains(dependency)) { DependsOn.Add(dependency); } } }
/// <summary> /// </summary> /// <returns>true if any task on the chain is marked as exclusive</returns> public bool IsChainExclusive() { if (Affinity == TaskAffinity.Exclusive) { return(true); } return(DependsOn?.IsChainExclusive() ?? false); }
protected override void FindDependentVariables(IEnumerable <MetaVariable <H, I> > allVariables) { visitor.DependedProperties.Clear(); visitor.Visit(Writer.Body); // добавляем все переменные связанные со свойствами, упоминаемыми в Writer.Body DependsOn.AddRange(allVariables.Where(d => visitor.DependedProperties.Contains(d.MetaProperty))); }
public ITask Finally <T>(T taskToContinueWith) where T : ITask { Guard.ArgumentNotNull(taskToContinueWith, nameof(taskToContinueWith)); continuationOnAlways = (TaskBase)(object)taskToContinueWith; continuationOnAlways.SetDependsOn(this); DependsOn?.SetFaultHandler(continuationOnAlways); return(continuationOnAlways); }
public void ToStringTest() { DependsOn.Windows(() => { string formatted1 = PathStringPool.Get(Path).ToString(PathStringFormatterTests.Format); Assert.AreEqual(Resources.PathStringToStringResult, formatted1); string formatted2 = PathStringPool.Get(Path).ToString(""); Assert.AreEqual(Path, formatted2); }); }
/// <inheritdoc/> public override int GetHashCode() { unchecked { var hashCode = DependsOn?.GetHashCode() ?? 0; hashCode = (hashCode * 397) ^ Timeout.GetHashCode(); hashCode = (hashCode * 397) ^ Recover.GetHashCode(); return(hashCode); } }
public void FormatTest() { DependsOn.Windows(() => { var path = PathStringPool.Get(PathStringTests.Path); var formatter = new PathStringFormatter(); string formatted = formatter.Format(Format, path, null); Assert.AreEqual(Resources.PathStringToStringResult, formatted); }); }
internal virtual ITask Finally <T>(T continuation) where T : ITask { Guard.ArgumentNotNull(continuation, "continuation"); continuation.SetDependsOn(this); this.continuation = (TaskBase)(object)continuation; this.continuationAlways = true; DependsOn?.SetFaultHandler((TaskBase)(object)continuation); return(continuation); }
public override DscResourceDto ToResourceDto() { return(new Dto.MergedPreferenceTests.MockDto { ResourceStepName = ResourceStepName, DependsOn = DependsOn.Select(x => x.ToResourceDto()).ToList(), Ensure = Ensure, ResourceName = ResourceName }); }
internal virtual ITask Finally <T>(T taskToContinueWith) where T : TaskBase { Guard.ArgumentNotNull(taskToContinueWith, nameof(taskToContinueWith)); continuation = (TaskBase)(object)taskToContinueWith; continuationAlways = true; continuation.SetDependsOn(this); DependsOn?.SetFaultHandler((TaskBase)(object)continuation); return(continuation); }
public override void RejectChanges() { DependsOn.RejectChanges(); Download.RejectChanges(); BaseFiles.RejectChanges(); ActiveFiles.RejectChanges(); SubMods.RejectChanges(); base.RejectChanges(); }
public void AddDependsOn(Project p) { if (!DependsOn.Contains(p)) { DependsOn.Add(p); } if (!p.IsDependencyFor.Contains(this)) { p.IsDependencyFor.Add(this); } }
public override DscResourceDto ToResourceDto() { return(new ChocolateySourceDto { ChocoPackageSource = ChocoPackageSource, Ensure = Ensure, ResourceStepName = ResourceStepName, ResourceName = ResourceName, DependsOn = DependsOn?.Select(x => x.ToResourceDto()).ToList() }); }
/// <summary> /// Throws an exception if the <see cref="BsipaManifest"/> is not valid. /// </summary> /// <param name="requiresBsipa"></param> /// <exception cref="ManifestValidationException"/> /// <exception cref="BsipaDependsOnException"/> public void Validate(bool requiresBsipa) { var nullProps = json.Linq.Where(n => n.Value == null || (n.Value.ToString() == string.Empty)).Select(n => n.Key).ToArray(); foreach (var prop in nullProps) { json.Remove(prop); } List <string> invalidProperties = new List <string>(); if (string.IsNullOrWhiteSpace(Id)) { invalidProperties.Add(nameof(Id)); } if (string.IsNullOrWhiteSpace(Name)) { invalidProperties.Add(nameof(Name)); } if (string.IsNullOrWhiteSpace(Author)) { invalidProperties.Add(nameof(Author)); } if (string.IsNullOrWhiteSpace(Version)) { invalidProperties.Add(nameof(Version)); } if (string.IsNullOrWhiteSpace(GameVersion) && requiresBsipa) { invalidProperties.Add(nameof(GameVersion)); } if (string.IsNullOrWhiteSpace(GetDescription())) { invalidProperties.Add(nameof(Description)); } if (requiresBsipa && !(DependsOn?.TryGetValue("BSIPA", out _) ?? false)) { throw new BsipaDependsOnException(); } if (invalidProperties.Count > 0) { string message; if (invalidProperties.Count == 1) { message = $"The property '{invalidProperties.First()}' cannot be empty."; } else { message = $"The properties '{string.Join(", ", invalidProperties)}' cannot be empty."; } throw new ManifestValidationException(message, invalidProperties); } }
/// <summary> /// This does not set a dependency between the two tasks. Instead, /// the Start method grabs the state of the previous task to pass on /// to the next task via previousSuccess and previousException /// </summary> /// <param name="handler"></param> internal void SetFaultHandler(TaskBase handler) { Task.ContinueWith(t => { Token.ThrowIfCancellationRequested(); handler.Start(t); }, Token, TaskContinuationOptions.OnlyOnFaulted, TaskManager.GetScheduler(handler.Affinity)); DependsOn?.SetFaultHandler(handler); }
public ITask Finally(Action <bool, Exception> continuation, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(continuation, "continuation"); var ret = new ActionTask(Token, continuation, this, true) { Affinity = affinity, Name = "Finally" }; DependsOn?.SetFaultHandler(ret); ret.ContinuationIsFinally = true; return(ret); }
public ITask Finally(Action <bool, Exception> actionToContinueWith, TaskAffinity affinity = TaskAffinity.Concurrent) { Guard.ArgumentNotNull(actionToContinueWith, nameof(actionToContinueWith)); var ret = Then(new ActionTask(Token, actionToContinueWith) { Affinity = affinity, Name = "Finally" }, true); DependsOn?.SetFaultHandler(ret); ret.ContinuationIsFinally = true; return(ret); }
protected Exception GetThrownException() { if (DependsOn == null) { return(null); } if (DependsOn.Task.Status == TaskStatus.Faulted) { var exception = DependsOn.Task.Exception; return(exception?.InnerException ?? exception); } return(DependsOn.GetThrownException()); }
public virtual ManifestModuleInfo LoadFromExternalManifest(ExternalModuleManifest manifest, ExternalModuleManifestVersion version) { if (manifest == null) { throw new ArgumentNullException(nameof(manifest)); } ModuleName = manifest.Id; if (version.Dependencies != null) { foreach (var dependency in version.Dependencies) { DependsOn.Add(dependency.Id); } } Id = manifest.Id; Version = version.SemanticVersion; VersionTag = version.VersionTag; PlatformVersion = version.PlatformSemanticVersion; ReleaseNotes = version.ReleaseNotes; Ref = version.PackageUrl; if (version.Dependencies != null) { Dependencies.AddRange(version.Dependencies.Select(x => new ModuleIdentity(x.Id, SemanticVersion.Parse(x.Version)))); } if (version.Incompatibilities != null) { Incompatibilities.AddRange(version.Incompatibilities.Select(x => new ModuleIdentity(x.Id, SemanticVersion.Parse(x.Version)))); } Title = manifest.Title; Description = manifest.Description; Authors = manifest.Authors; Owners = manifest.Owners; LicenseUrl = manifest.LicenseUrl; ProjectUrl = manifest.ProjectUrl; IconUrl = manifest.IconUrl; RequireLicenseAcceptance = manifest.RequireLicenseAcceptance; Copyright = manifest.Copyright; Tags = manifest.Tags; Identity = new ModuleIdentity(Id, Version); if (manifest.Groups != null) { Groups.AddRange(manifest.Groups); } return(this); }
/// <summary> /// Function to clone an object. /// </summary> /// <returns> /// The cloned object. /// </returns> public EditorFile Clone() { var result = new EditorFile(_filePath) { DependsOn = DependsOn.Clone(), PlugInType = PlugInType }; foreach (KeyValuePair <string, string> attrib in Attributes) { result.Attributes[attrib.Key] = attrib.Value; } return(result); }
public void SetDependency(params ThreadTask[] tasks) { var list = DependsOn.ToList(); list.AddRange(tasks); // clear finished from list for (int i = 0; i < list.Count; i++) { if (list[i].Finished) { list.RemoveAt(i); i--; } } DependsOn = list.ToArray(); }