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;
}
