public DataDependency <TTriggerer> AddNestedChildDependency <TTriggerer>( Func <TTriggerer, Task <IEnumerable <IEntity> > > childDependents) where TTriggerer : class, IEntity { var dep = new DataDependency <TTriggerer>( async child => { var deps = await childDependents(child); if (deps == null) { return(null); } foreach (var x in deps) { if (x != null) { await RaiseSaveEventFor(x); } } return(null); }); Dependencies.Add(dep); return(dep); }
/// <summary> /// Creates a new instance of the <see cref="Enumerator"/> structure. /// </summary> /// <param name="collection">The collection to enumerate.</param> public Enumerator(StackDependencyCollection <TContents> collection) : this() { _collection = collection; _index = -1; _current = null; }
/// <inheritdoc /> protected override void SetItem(int index, DataDependency <TContents> item) { AssertDependencyValidity(item); RemoveAt(index); Insert(index, item); }
/// <summary> /// Marks this type as dependant directly to an associated master entity type. /// Use this for many-to-one associations. /// </summary> public DataDependency AddDependency <TTriggerer>(Expression <Func <TDomain, TTriggerer> > dependency) where TTriggerer : class, IEntity { var dep = new DataDependency <TTriggerer>(p => FromDB <TDomain>(p.GetId(), dependency.GetProperty())); Dependencies.Add(dep); return(dep); }
/// <summary> /// Define the reverse side of a master-detail relationship, where the details' data is exposed via this master object. /// Use this for exposed one-to-many associations to declare the child dependency. /// </summary> public DataDependency <TChildEntity> AddChildDependency <TChildEntity>(Expression <Func <TChildEntity, TDomain> > dependency) where TChildEntity : class, IEntity { var function = dependency.Compile(); var dep = new DataDependency <TChildEntity>(p => Task.FromResult <IEnumerable <TDomain> >(new[] { function?.Invoke(p) })); Dependencies.Add(dep); return(dep); }
internal static AstVariableCollection CollectDependencies( AstParserContext <TInstruction> context, IVariable variable, DataDependency <TInstruction> dependency) { var result = new AstVariableCollection(); foreach (long offset in dependency.Select(d => context.Architecture.GetOffset(d.Node.Contents))) { if (context.InstructionVersionStates.TryGetValue(offset, out var versions)) { result.Add(context.VersionedAstVariables[(variable, versions[variable])]);
/// <inheritdoc /> public bool MoveNext() { _index++; if (_index < _collection.Count) { _current = _collection[_index]; return(true); } _current = null; return(false); }
public void RemoveStackDependencyShouldUnsetDependant() { var dfg = new DataFlowGraph <int>(IntArchitecture.Instance); var n0 = dfg.Nodes.Add(0, 0); var n1 = dfg.Nodes.Add(1, 1); var symbolicValue = new DataDependency <int>(n0); n1.StackDependencies.Add(symbolicValue); n1.StackDependencies.Remove(symbolicValue); Assert.Null(symbolicValue.Dependant); }
public void AddStackDependencyShouldSetDependant() { var dfg = new DataFlowGraph <int>(IntArchitecture.Instance); var n0 = dfg.Nodes.Add(0, 0); var n1 = dfg.Nodes.Add(1, 1); var dependency = new DataDependency <int>(n0); n1.StackDependencies.Add(dependency); Assert.Same(n1, dependency.Dependant); }
private void AssertDependencyValidity(DataDependency <TContents> item) { if (item == null) { throw new ArgumentNullException(nameof(item)); } if (item.Dependant != null) { throw new ArgumentException("Stack dependency was already added to another node."); } if (item.Any(n => n.Node.ParentGraph != _owner.ParentGraph)) { throw new ArgumentException("Dependency contains data sources from another graph."); } }
public void AddStackDependencyShouldAddToDependants() { var dfg = new DataFlowGraph <int>(IntArchitecture.Instance); var n0 = dfg.Nodes.Add(0, 0); var n1 = dfg.Nodes.Add(1, 1); var n2 = dfg.Nodes.Add(2, 2); var dependency1 = new DataDependency <int>(n0); n1.StackDependencies.Add(dependency1); var dependency2 = new DataDependency <int>(n0); n2.StackDependencies.Add(dependency2); Assert.Equal(new HashSet <DataFlowNode <int> > { n1, n2 }, new HashSet <DataFlowNode <int> >(n0.GetDependants())); }
public void AddToDataDependency(DataDependency dataDependency) { base.AddObject("DataDependency", dataDependency); }
public static DataDependency CreateDataDependency(global::System.Guid ID) { DataDependency dataDependency = new DataDependency(); dataDependency.ID = ID; return dataDependency; }
/// <inheritdoc /> protected override void InsertItem(int index, DataDependency <TContents> item) { AssertDependencyValidity(item); base.InsertItem(index, item); item.Dependant = _owner; }
/// <inheritdoc /> public void Reset() { _index = -1; _current = null; }