public WalkingVertex(DependencyVertex <TKey, TValue> vertex)
{
DependencyVertex = vertex;
Index = -1;
LoopNumber = -1;
_outgoing = new List <WalkingVertex <TKey, TValue> >();
}
public DependencyVertex <TKey, TValue> AddOrUpdate(TKey key, TValue value, ImmutableArray <TKey> incomingKeys)
{
var version = Snapshot.Version + 1;
DependencyVertex <TKey, TValue> changedVertex;
if (_verticesByKey.TryGetValue(key, out var currentVertex))
{
changedVertex = new DependencyVertex <TKey, TValue>(currentVertex, value, incomingKeys, version);
_verticesByIndex[changedVertex.Index] = changedVertex;
}
else
{
changedVertex = new DependencyVertex <TKey, TValue>(key, value, incomingKeys, version, _verticesByIndex.Count);
_verticesByIndex.Add(changedVertex);
}
_verticesByKey[key] = changedVertex;
var vertices = _verticesByIndex
.Where(v => !v.IsSealed || v.HasMissingKeys)
.Select(v => GetOrCreateNonSealedVertex(version, v.Index))
.ToArray();
if (vertices.Length == 0)
{
Snapshot = new DependencyGraphSnapshot <TKey, TValue>(version);
return(changedVertex);
}
CreateNewSnapshot(vertices, version);
return(changedVertex);
}
public WalkingVertex(DependencyVertex <TKey, TValue> vertex, WalkingVertex <TKey, TValue> firstPass = null)
{
DependencyVertex = vertex;
FirstPass = firstPass;
Index = -1;
LoopNumber = firstPass?.LoopNumber ?? -1;
_outgoing = new List <WalkingVertex <TKey, TValue> >();
}
private void CommitChanges(DependencyVertex <TKey, TValue> vertex)
{
lock (_syncObj) {
if (_changedVertices.TryGetValue(vertex.Key, out var changedVertex) && changedVertex.Version <= vertex.Version)
{
_changedVertices.Remove(vertex.Key);
}
}
}
public DependencyVertex(DependencyVertex <TKey, TValue> oldVertex, TValue value, ImmutableArray <TKey> incomingKeys, int version)
{
Key = oldVertex.Key;
Value = value;
Version = version;
Index = oldVertex.Index;
IncomingKeys = incomingKeys;
Incoming = oldVertex.Incoming;
Outgoing = oldVertex.Outgoing;
}
public DependencyVertex(DependencyVertex <TKey, TValue> oldVertex, int version, bool isNew)
{
Key = oldVertex.Key;
Value = oldVertex.Value;
IsRoot = oldVertex.IsRoot;
Index = oldVertex.Index;
Incoming = oldVertex.Incoming;
Version = version;
_outgoing = oldVertex.Outgoing;
_state = !isNew && oldVertex.IsWalked ? (int)State.ChangedOutgoing : (int)State.New;
}
private DependencyVertex <TKey, TValue> GetOrCreateNonSealedVertex(int version, int index)
{
var vertex = _verticesByIndex[index];
if (!vertex.IsSealed)
{
return(vertex);
}
vertex = new DependencyVertex <TKey, TValue>(vertex, vertex.Value, vertex.IncomingKeys, version);
_verticesByIndex[index] = vertex;
_verticesByKey[vertex.Key] = vertex;
return(vertex);
}
public void RemoveKeys(ImmutableArray <TKey> keys)
{
var version = Snapshot.Version + 1;
_verticesByIndex.Clear();
foreach (var key in keys)
{
_verticesByKey.Remove(key);
}
foreach (var(key, currentVertex) in _verticesByKey)
{
var changedVertex = new DependencyVertex <TKey, TValue>(key, currentVertex.Value, currentVertex.IncomingKeys, version, _verticesByIndex.Count);
_verticesByIndex.Add(changedVertex);
}
foreach (var vertex in _verticesByIndex)
{
_verticesByKey[vertex.Key] = vertex;
}
CreateNewSnapshot(_verticesByIndex, version);
}
public DependencyVertex <TKey, TValue> AddOrUpdate(TKey key, TValue value, ImmutableArray <TKey> incomingKeys)
{
var version = Snapshot.Version + 1;
DependencyVertex <TKey, TValue> changedVertex;
if (_verticesByKey.TryGetValue(key, out var currentVertex))
{
changedVertex = new DependencyVertex <TKey, TValue>(currentVertex, value, incomingKeys, version);
_verticesByIndex[changedVertex.Index] = changedVertex;
}
else
{
changedVertex = new DependencyVertex <TKey, TValue>(key, value, incomingKeys, version, _verticesByIndex.Count);
_verticesByIndex.Add(changedVertex);
}
_verticesByKey[key] = changedVertex;
var missingKeysHashSet = new HashSet <TKey>();
var vertices = _verticesByIndex
.Where(v => !v.IsSealed || v.HasMissingKeys)
.Select(v => GetOrCreateNonSealedVertex(version, v.Index))
.ToArray();
if (vertices.Length == 0)
{
Snapshot = new DependencyGraphSnapshot <TKey, TValue>(version);
return(changedVertex);
}
foreach (var vertex in vertices)
{
var newIncoming = ImmutableArray <int> .Empty;
var oldIncoming = vertex.Incoming;
foreach (var dependencyKey in vertex.IncomingKeys)
{
if (_verticesByKey.TryGetValue(dependencyKey, out var dependency))
{
newIncoming = newIncoming.Add(dependency.Index);
}
else
{
missingKeysHashSet.Add(dependencyKey);
vertex.SetHasMissingKeys();
}
}
foreach (var index in oldIncoming.Except(newIncoming))
{
var incomingVertex = GetOrCreateNonSealedVertex(version, index);
incomingVertex.RemoveOutgoing(vertex.Index);
}
foreach (var index in newIncoming.Except(oldIncoming))
{
var incomingVertex = GetOrCreateNonSealedVertex(version, index);
incomingVertex.AddOutgoing(vertex.Index);
}
vertex.SetIncoming(newIncoming);
}
foreach (var vertex in _verticesByIndex)
{
vertex.Seal();
}
Snapshot = new DependencyGraphSnapshot <TKey, TValue>(version,
ImmutableArray <DependencyVertex <TKey, TValue> > .Create(_verticesByIndex),
ImmutableArray <TKey> .Create(missingKeysHashSet));
return(changedVertex);
}
