public void AddNodeAndBackwardEdge(LevelKey myPath, IVertex aVertex, EdgeKey backwardDirection, VertexInformation backwardDestination, IComparable EdgeWeight, IComparable NodeWeight)
{
lock (_Content)
{
var node = GenerateVertexInfoFromLevelKeyAndVertexID(aVertex.VertexTypeID, aVertex.VertexID);
if (_Content.ContainsKey(myPath))
{
//the level exists
if (_Content[myPath].Nodes.ContainsKey(node))
{
//Node exists
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
else
{
//Node does not exist
_Content[myPath].Nodes.Add(node, new ExpressionNode(aVertex, NodeWeight, node));
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
}
else
{
HashSet <IExpressionEdge> backwardEdges = new HashSet <IExpressionEdge>()
{
new ExpressionEdge(backwardDestination, EdgeWeight, backwardDirection)
};
_Content.Add(myPath, new ExpressionLevelEntry(myPath));
_Content[myPath].Nodes.Add(node, new ExpressionNode(aVertex, NodeWeight, node));
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
}
}
public void AddBackwardEdgesToNode(LevelKey myPath, VertexInformation myVertexInformation, EdgeKey backwardDestination, Dictionary <VertexInformation, IComparable> validUUIDs)
{
lock (_Content)
{
if (_Content.ContainsKey(myPath))
{
//the level exists
if (_Content[myPath].Nodes.ContainsKey(myVertexInformation))
{
//Node exists
_Content[myPath].Nodes[myVertexInformation].AddBackwardEdges(backwardDestination, validUUIDs);
}
else
{
//Node does not exist
throw new ExpressionGraphInternalException("The node does not exist in this LevelKey.");
}
}
else
{
//LevelKey does not exist
throw new ExpressionGraphInternalException("The LevelKey does not exist in this ExpressionLevel.");
}
}
}
public void AddForwardEdgeToNode(LevelKey levelKey, VertexInformation myVertexInformation, EdgeKey forwardDirection, VertexInformation destination, IComparable edgeWeight)
{
lock (_Content)
{
if (_Content.ContainsKey(levelKey))
{
//the level exists
if (_Content[levelKey].Nodes.ContainsKey(myVertexInformation))
{
//Node exists
_Content[levelKey].Nodes[myVertexInformation].AddForwardEdge(forwardDirection, destination, edgeWeight);
}
else
{
//Node does not exist
throw new ExpressionGraphInternalException("The node does not exist in this LevelKey.");
}
}
else
{
//LevelKey does not exist
throw new ExpressionGraphInternalException("The LevelKey does not exist in this ExpressionLevel.");
}
}
}
public LevelKey AddLevelKey(LevelKey myLevelKey2, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
if ((this.Edges == null || this.Edges.Count == 0) && (myLevelKey2.Edges == null || myLevelKey2.Edges.Count == 0))
{
return(new LevelKey());
}
else if (this.Edges == null || this.Edges.Count == 0)
{
return(new LevelKey(myLevelKey2.Edges, myGraphDB, mySecurityToken, myTransactionToken));
}
else if (myLevelKey2.Edges == null || myLevelKey2.Edges.Count == 0)
{
return(new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken));
}
if (this.Level == 0 && myLevelKey2.Level == 0)
{
#region both are level 0 (User/null)
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
{
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
}
else
{
return(new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken));
}
#endregion
}
else if (this.Level == 0)
{
#region one of them is level 0 - so we can just skip this level: User/null + User/Friends == User/Friends
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
{
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
}
else
{
return(new LevelKey(myLevelKey2.Edges, myGraphDB, mySecurityToken, myTransactionToken)); // just return the other level
}
#endregion
}
else if (myLevelKey2.Level == 0)
{
#region one of them is level 0 - so we can just skip this level: User/null + User/Friends == User/Friends
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
{
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
}
else
{
return(new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken)); // just return the other level
}
#endregion
}
var edges = new List <EdgeKey>(this.Edges);
edges.AddRange(myLevelKey2.Edges);
return(new LevelKey(edges, myGraphDB, mySecurityToken, myTransactionToken));
}
public LevelKey RemoveLevelKey(LevelKey myOtherLevelKey, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
if (this.Level < myOtherLevelKey.Level)
{
throw new ArgumentException("level of left (" + this.Level + ") operand is lower than right (" + myOtherLevelKey.Level + ") operand:", "myOtherLevelKey");
}
if (!this.StartsWith(myOtherLevelKey, true))
{
throw new ArgumentException("left operand level does not starts with right operand level");
}
if (myOtherLevelKey.Level == 0)
{
return(this);
}
if (this.Level == myOtherLevelKey.Level)
{
return(new LevelKey(this.Edges[0].VertexTypeID, myGraphDB, mySecurityToken, myTransactionToken));
}
var edgeList = new List <EdgeKey>(this.Edges);
return(new LevelKey(this.Edges.Skip(myOtherLevelKey.Edges.Count), myGraphDB, mySecurityToken, myTransactionToken));
}
protected EdgeKey GetBackwardEdgeKey(LevelKey myPath, int desiredBELevel, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
#region data
IVertexType tempType;
IAttributeDefinition tempAttr;
#endregion
tempType = myGraphDB.GetVertexType <IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(myPath.Edges[desiredBELevel].VertexTypeID),
(stats, vertexType) => vertexType);
tempAttr = tempType.GetAttributeDefinition(myPath.Edges[desiredBELevel].AttributeID);
if (tempAttr.Kind != AttributeType.IncomingEdge)
{
return(new EdgeKey(tempType.ID, tempAttr.ID));
}
else
{
IIncomingEdgeDefinition incomingEdgeDefinition = tempAttr as IIncomingEdgeDefinition;
return(new EdgeKey(incomingEdgeDefinition.RelatedEdgeDefinition.SourceVertexType.ID, incomingEdgeDefinition.RelatedEdgeDefinition.ID));
}
}
public Boolean HasLevelKey(LevelKey myLevelKey)
{
lock (_Content)
{
return(_Content.ContainsKey(myLevelKey));
}
}
public void AddEmptyLevelKey(LevelKey levelKey)
{
lock (_Content)
{
if (!_Content.ContainsKey(levelKey))
{
_Content.Add(levelKey, new ExpressionLevelEntry(levelKey));
}
}
}
public void RemoveComplexConnection(LevelKey myLevelKey, VertexInformation myUUID)
{
lock (_lockObj)
{
if (_ComplexConnection.ContainsKey(myLevelKey))
{
_ComplexConnection[myLevelKey].Remove(myUUID);
}
}
}
public void RemoveNode(LevelKey myLevelKey, VertexInformation myToBeRemovedVertex)
{
lock (_Content)
{
if (_Content.ContainsKey(myLevelKey))
{
_Content[myLevelKey].Nodes.Remove(myToBeRemovedVertex);
}
}
}
public Dictionary <VertexInformation, IExpressionNode> GetNode(LevelKey myLevelKey)
{
lock (_Content)
{
if (_Content.ContainsKey(myLevelKey))
{
return(_Content[myLevelKey].Nodes);
}
return(null);
}
}
public IEnumerable <IExpressionNode> GetNodes(LevelKey myLevelKey)
{
lock (_Content)
{
if (_Content.ContainsKey(myLevelKey))
{
return(_Content[myLevelKey].Nodes.Values);
}
return(null);
}
}
public bool StartsWith(LevelKey myLevel)
{
if (myLevel.Level > Level)
{
throw new ArgumentException(myLevel + " is greater than " + Level);
}
for (Int32 i = 0; i < myLevel.Level; i++)
{
if (myLevel.Edges[i].VertexTypeID != Edges[i].VertexTypeID)
{
return(false);
}
}
return(true);
}
public void AddComplexConnection(LevelKey myLevelKey, VertexInformation myUUID)
{
lock (_lockObj)
{
if (_ComplexConnection.ContainsKey(myLevelKey))
{
_ComplexConnection[myLevelKey].Add(myUUID);
}
else
{
_ComplexConnection.Add(myLevelKey, new HashSet <VertexInformation>()
{
myUUID
});
}
}
}
public bool ContainsLevelKey(LevelKey levelKey)
{
if (this.Levels.ContainsKey(levelKey.Level))
{
if (this.Levels[levelKey.Level].ExpressionLevels.ContainsKey(levelKey))
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
public bool ContainsLevelKey(LevelKey levelKey)
{
if (this.Levels.ContainsKey(levelKey.Level))
{
if (this.Levels[levelKey.Level].ExpressionLevels.ContainsKey(levelKey))
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
public override Boolean Equals(System.Object obj)
{
// If parameter is null return false.
if (obj == null)
{
return(false);
}
// If parameter cannot be cast to Point return false.
if (obj is LevelKey)
{
LevelKey p = (LevelKey)obj;
return(Equals(p));
}
else
{
return(false);
}
}
public bool StartsWith(LevelKey myLevel, Boolean IncludingAttrs)
{
if (!IncludingAttrs)
{
return(StartsWith(myLevel));
}
if (myLevel.Level > Level)
{
throw new ArgumentException(myLevel + " is greater than " + Level);
}
for (Int32 i = 0; i < myLevel.Level; i++)
{
if (myLevel.Edges[i].VertexTypeID != Edges[i].VertexTypeID || myLevel.Edges[i].AttributeID != Edges[i].AttributeID)
{
return(false);
}
}
return(true);
}
public void AddNodeAndBackwardEdge(LevelKey myPath, IVertex aVertex, EdgeKey backwardDirection, VertexInformation backwardDestination, IComparable EdgeWeight, IComparable NodeWeight)
{
lock (_Content)
{
var node = GenerateVertexInfoFromLevelKeyAndVertexID(aVertex.VertexTypeID, aVertex.VertexID);
if (_Content.ContainsKey(myPath))
{
//the level exists
if (_Content[myPath].Nodes.ContainsKey(node))
{
//Node exists
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
else
{
//Node does not exist
_Content[myPath].Nodes.Add(node, new ExpressionNode(aVertex, NodeWeight, node));
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
}
else
{
HashSet<IExpressionEdge> backwardEdges = new HashSet<IExpressionEdge>() { new ExpressionEdge(backwardDestination, EdgeWeight, backwardDirection) };
_Content.Add(myPath, new ExpressionLevelEntry(myPath));
_Content[myPath].Nodes.Add(node, new ExpressionNode(aVertex, NodeWeight, node));
_Content[myPath].Nodes[node].AddBackwardEdge(backwardDirection, backwardDestination, EdgeWeight);
}
}
}
public Boolean Equals(LevelKey p)
{
// If parameter is null return false:
if ((object)p == null)
{
return(false);
}
if (this.Level != p.Level)
{
return(false);
}
for (int i = 0; i < Edges.Count; i++)
{
if (this.Edges[i] != p.Edges[i])
{
return(false);
}
}
return(true);
}
public void AddNode(LevelKey levelKey, IExpressionNode expressionNode)
{
lock (_Content)
{
if (_Content.ContainsKey(levelKey))
{
var tempInt64 = expressionNode.GetIVertex().VertexID;
var node = expressionNode.VertexInformation;
if (_Content[levelKey].Nodes.ContainsKey(node))
{
//the node already exist, so update its edges
foreach (var aBackwardEdge in expressionNode.BackwardEdges)
{
_Content[levelKey].Nodes[node].AddBackwardEdges(aBackwardEdge.Value);
}
foreach (var aForwardsEdge in expressionNode.ForwardEdges)
{
_Content[levelKey].Nodes[node].AddForwardEdges(aForwardsEdge.Value);
}
}
else
{
_Content[levelKey].Nodes.Add(node, expressionNode);
}
}
else
{
_Content.Add(levelKey, new ExpressionLevelEntry(levelKey));
_Content[levelKey].Nodes.Add(expressionNode.VertexInformation, expressionNode);
}
}
}
public abstract void AddNodes(IEnumerable<IExpressionNode> iEnumerable, LevelKey myPath);
public abstract void AddNode(IVertex myVertex, LevelKey myIDNode);
public abstract void GatherEdgeWeight(LevelKey StartLevel, LevelKey EndLevel);
/// <summary>
/// We need to add an empty level in case, the DBO should not be integerated. Otherwise the select does not know, either the level was never touched or
/// not added due to an expression
/// </summary>
/// <param name="myExpressionGraph"></param>
/// <param name="myLevelKey"></param>
private void ExcludeFromGraph(IExpressionGraph myExpressionGraph, LevelKey myLevelKey)
{
myExpressionGraph.AddEmptyLevel(myLevelKey);
}
private static void CleanLowerLevel(LevelKey myLevelKey, IExpressionGraph myGraph, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
if (myLevelKey.Level > 0)
{
var previousLevelKey = myLevelKey.GetPredecessorLevel(myGraphDB, mySecurityToken, myTransactionToken);
HashSet<VertexInformation> toBeDeletedNodes = new HashSet<VertexInformation>();
foreach (var aLowerDBO in myGraph.Select(previousLevelKey, null, false))
{
if (aLowerDBO.HasOutgoingEdge(myLevelKey.LastEdge.AttributeID))
{
foreach (var aVertex in aLowerDBO.GetOutgoingEdge(myLevelKey.LastEdge.AttributeID).GetTargetVertices())
{
//took the vertextype id of the levelkey, because it is possible that the vertextypeid of the vertex is something inheritated
VertexInformation node = new VertexInformation(aVertex.VertexTypeID, aVertex.VertexID);
if (!myGraph.GetLevel(myLevelKey.Level).ExpressionLevels[myLevelKey].Nodes.ContainsKey(node))
{
//a reference occurred that is not in the higher level --> found a Zoidberg
toBeDeletedNodes.Add(node);
break;
}
}
}
}
foreach (var aToBeDeletedNode in toBeDeletedNodes)
{
myGraph.GetLevel(previousLevelKey.Level).RemoveNode(previousLevelKey, aToBeDeletedNode);
}
}
}
public override Boolean IsGraphRelevant(LevelKey myLevelKey, IVertex mySourceDBObject)
{
lock (_Levels)
{
if (!this.ContainsLevelKey(myLevelKey))
{
return false;
}
if (myLevelKey.Level == 0)
{
return this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes.ContainsKey(GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID));
}
else
{
if (mySourceDBObject != null)
{
VertexInformation mySourceDBObjectNode = GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID);
var predecessorLevelKey = myLevelKey.GetPredecessorLevel(_iGraphDB, _securityToken, _transactionToken);
if (!this.ContainsLevelKey(predecessorLevelKey))
{
var interestingEdge = new ExpressionEdge(mySourceDBObjectNode, null, predecessorLevelKey.LastEdge);
//take the backwardEdges
return this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes.Where(item => item.Value.BackwardEdges[predecessorLevelKey.LastEdge].Contains(interestingEdge)).Count() > 0;
}
else
{
if (this._Levels[predecessorLevelKey.Level].ExpressionLevels[predecessorLevelKey].Nodes[mySourceDBObjectNode].ForwardEdges.ContainsKey(myLevelKey.LastEdge))
{
if (this._Levels[predecessorLevelKey.Level].ExpressionLevels[predecessorLevelKey].Nodes[mySourceDBObjectNode].ForwardEdges[myLevelKey.LastEdge].Count > 0)
{
return true;
}
else
{
return false;
}
}
else
{
return false;
}
}
}
else
{
throw new ExpressionGraphInternalException("No IVertex givon for graph relevance test in a higher level.");
}
}
}
}
public override void GatherEdgeWeight(LevelKey StartLevel, LevelKey EndLevel)
{
throw new NotImplementedException();
}
public abstract void AddNode(IVertex myVertex, LevelKey myIDNode);
public abstract void AddNodesWithComplexRelation(IVertex leftVertex, LevelKey leftLevelKey, IVertex rightVertex, LevelKey rightLevelKey, int backwardResolution);
public abstract Boolean IsGraphRelevant(LevelKey myLevelKey, IVertex mySourceVertex);
public abstract IEnumerable <VertexInformation> SelectVertexIDs(LevelKey myLevelKey, IVertex mySourceVertex = null, Boolean generateLevel = true);
public abstract IEnumerable <IVertex> Select(LevelKey myLevelKey, IVertex mySourceVertex = null, Boolean generateLevel = true);
public abstract IEnumerable<VertexInformation> SelectVertexIDs(LevelKey myLevelKey, IVertex mySourceVertex = null, Boolean generateLevel = true);
public abstract void AddNodesWithComplexRelation(IVertex leftVertex, LevelKey leftLevelKey, IVertex rightVertex, LevelKey rightLevelKey, int backwardResolution);
public override IEnumerable<IVertex> Select(LevelKey myLevelKey, IVertex mySourceDBObject = null, Boolean doLevelGeneration = true)
{
lock (_Levels)
{
if (doLevelGeneration)
{
if (!this.ContainsLevelKey(myLevelKey))
{
//the graph does not contain the LevelKey, so create it
#region create LevelKey
GenerateLevel(myLevelKey);
#endregion
}
}
if (myLevelKey.Level == 0)
{
if (this.ContainsLevelKey(myLevelKey))
{
//return all Objects of this levelKey
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes)
{
yield return aNode.Value.GetIVertex();
}
}
else
{
yield break;
}
}
else
{
if (mySourceDBObject != null)
{
var predecessorLevelKey = myLevelKey.GetPredecessorLevel(_iGraphDB, _securityToken, _transactionToken);
if (!this.ContainsLevelKey(predecessorLevelKey))
{
var sourceNode = GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID);
//take the backwardEdges
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes.Where(item => item.Value.BackwardEdges[predecessorLevelKey.LastEdge].Where(aBackWardEdge => aBackWardEdge.Destination == sourceNode).Count() > 0))
{
yield return aNode.Value.GetIVertex();
}
}
else
{
//take the forwardEdges
var interestingVertexIDs = this._Levels[predecessorLevelKey.Level]
.ExpressionLevels[predecessorLevelKey]
.Nodes[GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID)]
.ForwardEdges[myLevelKey.LastEdge].Select(item => item.Destination);
foreach (var aInterestingID in interestingVertexIDs)
{
yield return this._Levels[myLevelKey.Level]
.ExpressionLevels[myLevelKey]
.Nodes[aInterestingID].GetIVertex();
}
}
}
else
{
//there is no sourceObject given, so return the complete level
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes)
{
yield return aNode.Value.GetIVertex();
}
}
}
}
//all done
yield break;
}
public ExpressionLevelEntry(LevelKey myCorrespondingLevelKey)
: this(myCorrespondingLevelKey, new Dictionary <VertexInformation, IExpressionNode>())
{
}
public override IEnumerable<VertexInformation> SelectVertexIDs(LevelKey myLevelKey, IVertex mySourceDBObject = null, Boolean doLevelGeneration = true)
{
lock (_Levels)
{
if (doLevelGeneration)
{
if (!this.ContainsLevelKey(myLevelKey))
{
//the graph does not contain the LevelKey, so create it
#region create LevelKey
GenerateLevel(myLevelKey);
#endregion
}
}
if (myLevelKey.Level == 0)
{
if (this.ContainsLevelKey(myLevelKey))
{
//return all Objects of this levelKey
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes)
{
yield return aNode.Value.VertexInformation;
}
}
else
{
yield break;
}
}
else
{
if (mySourceDBObject != null)
{
var predecessorLevelKey = myLevelKey.GetPredecessorLevel(_iGraphDB, _securityToken, _transactionToken);
if (!this.ContainsLevelKey(predecessorLevelKey))
{
var node = GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID);
//take the backwardEdges
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes.Where(item => item.Value.BackwardEdges[predecessorLevelKey.LastEdge].Where(aBackWardEdge => aBackWardEdge.Destination == node).Count() > 0))
{
yield return aNode.Value.VertexInformation;
}
}
else
{
//took the vertextypeid of the levelkey, because the vertextypeid of the sourceDBObject can be sth inheritated
VertexInformation source = GenerateVertexInfoFromLevelKeyAndVertexID(mySourceDBObject.VertexTypeID, mySourceDBObject.VertexID);
//take the forwardEdges
if (this._Levels[predecessorLevelKey.Level].ExpressionLevels[predecessorLevelKey].Nodes[source].ForwardEdges.ContainsKey(myLevelKey.LastEdge))
{
foreach (var aUUID in this._Levels[predecessorLevelKey.Level].ExpressionLevels[predecessorLevelKey].Nodes[source].ForwardEdges[myLevelKey.LastEdge].Select(item => item.Destination))
{
yield return aUUID;
}
}
//else
//{
// AddNode(mySourceDBObject, myLevelKey);
// //var attrVal = mySourceDBObject.GetAttribute(myLevelKey.LastEdge.AttrUUID);
//}
}
}
else
{
//there is no sourceObject given, so return the complete level
foreach (var aNode in this._Levels[myLevelKey.Level].ExpressionLevels[myLevelKey].Nodes)
{
yield return aNode.Value.VertexInformation;
}
}
}
}
//all done
yield break;
}
public abstract void AddNodes(IEnumerable <IExpressionNode> iEnumerable, LevelKey myPath);
/// <summary>
/// This method adds a IVertex to a Level if it is valid for a LevelKey.
/// </summary>
/// <param name="aDBObject">The Object that is going to be added</param>
/// <param name="myLevelKey">The LevelKey which is needed for validation.</param>
/// <param name="currentBackwardResolution">The current backward resolution (initially 0)</param>
/// <param name="source">The Int64 of the </param>
/// <returns>True if it was valid or false otherwise.</returns>
private bool AddNodeIfValid(IVertex aDBObject, LevelKey myLevelKey, int currentBackwardResolution, VertexInformation source, int backwardResolutiondepth)
{
#region data
IAttributeDefinition tempTypeAttribute = null;
IEnumerable<IVertex> referenceUUIDs = null;
#endregion
if ((myLevelKey.Level - currentBackwardResolution) > 0)
{
#region level > 0
int desiredBackwardEdgeLevel = myLevelKey.Level - currentBackwardResolution - 1;
var tempVertexType = _iGraphDB.GetVertexType(
_securityToken,
_transactionToken,
new RequestGetVertexType(myLevelKey.Edges[desiredBackwardEdgeLevel].VertexTypeID),
(stats, vertexType) => vertexType);
tempTypeAttribute = tempVertexType.GetAttributeDefinition(myLevelKey.Edges[desiredBackwardEdgeLevel].AttributeID);
#region get reference UUIDs
if (tempTypeAttribute.Kind == AttributeType.IncomingEdge)
{
#region backward edge handling
var incomingEdgeAttribute = tempTypeAttribute as IIncomingEdgeDefinition;
if (aDBObject.HasOutgoingEdge(incomingEdgeAttribute.RelatedEdgeDefinition.ID))
{
referenceUUIDs = aDBObject.GetOutgoingEdge(incomingEdgeAttribute.RelatedEdgeDefinition.ID).GetTargetVertices();
//GetUUIDsForAttribute(aDBObject, incomingEdgeAttribute.RelatedEdgeDefinition, tempTypeAttribute.BackwardEdgeDefinition.GetTypeAndAttributeInformation(_DBContext.DBTypeManager).Item2, _DBContext.DBTypeManager.GetTypeByUUID(aDBObject.TypeUUID));
}
#endregion
}
else
{
#region forward edge handling
var tempEdgeKey = GetBackwardEdgeKey(myLevelKey, desiredBackwardEdgeLevel, _iGraphDB, _securityToken, _transactionToken);
if (!aDBObject.HasIncomingVertices(tempEdgeKey.VertexTypeID, tempEdgeKey.AttributeID))
{
return false;
}
referenceUUIDs = aDBObject.GetIncomingVertices(tempEdgeKey.VertexTypeID, tempEdgeKey.AttributeID);
#endregion
}
#endregion
if (referenceUUIDs != null)
{
#region references
Dictionary<VertexInformation, IComparable> validUUIDs = new Dictionary<VertexInformation, IComparable>();
#region process references recursivly
foreach (var aReferenceUUID in referenceUUIDs)
{
if (AddNodeIfValid(aReferenceUUID, myLevelKey, currentBackwardResolution + 1, GenerateVertexInfoFromLevelKeyAndVertexID(aDBObject.VertexTypeID, aDBObject.VertexID), backwardResolutiondepth))
{
validUUIDs.Add(GenerateVertexInfoFromLevelKeyAndVertexID(aReferenceUUID.VertexTypeID, aReferenceUUID.VertexID), null);
}
}
#endregion
if (validUUIDs.Count > 0)
{
//some valid uuids
if (currentBackwardResolution <= backwardResolutiondepth)
{
#region fill graph
FillGraph(aDBObject, myLevelKey, currentBackwardResolution, source, myLevelKey.Edges[desiredBackwardEdgeLevel], validUUIDs);
#endregion
}
return true;
}
else
{
//not valid
return false;
}
#endregion
}
else
{
#region no references
return false;
#endregion
}
#endregion
}
else
{
#region Level 0
if (currentBackwardResolution <= backwardResolutiondepth)
{
#region fill graph
LevelKey newLevelKey = new LevelKey(myLevelKey.Edges.First().VertexTypeID, _iGraphDB, _securityToken, _transactionToken);
if (currentBackwardResolution > 0)
{
//we have to add forwardEdges and (if not already there) add nodes
AddEmptyLevel(newLevelKey);
var node = GenerateVertexInfoFromLevelKeyAndVertexID(aDBObject.VertexTypeID, aDBObject.VertexID);
Levels[0].AddNode(newLevelKey, new ExpressionNode(aDBObject, null, node));
Levels[0].AddForwardEdgeToNode(newLevelKey, node, new EdgeKey(myLevelKey.Edges[0].VertexTypeID, myLevelKey.Edges[0].AttributeID), source, null);
}
else
{
//we are in the lowest level and are the first time in this method... so there's no need for adding forward-edges to nodes
AddEmptyLevel(newLevelKey);
Levels[0].AddNode(newLevelKey, new ExpressionNode(aDBObject, null, GenerateVertexInfoFromLevelKeyAndVertexID(aDBObject.VertexTypeID, aDBObject.VertexID)));
}
#endregion
}
return true;
#endregion
}
}
private static void IntegrateInGraph(IVertex myDBObjectStream, IExpressionGraph myExpressionGraph, LevelKey myLevelKey, TypesOfOperators myTypesOfOperators)
{
if (myTypesOfOperators == TypesOfOperators.AffectsLowerLevels)
{
myExpressionGraph.AddNode(myDBObjectStream, myLevelKey, 1);
}
else
{
myExpressionGraph.AddNode(myDBObjectStream, myLevelKey, 0);
}
}
public abstract void AddNode(IVertex myVertex, LevelKey myIDNode, int backwardResolution);
protected EdgeKey GetBackwardEdgeKey(LevelKey myPath, int desiredBELevel, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
#region data
IVertexType tempType;
IAttributeDefinition tempAttr;
#endregion
tempType = myGraphDB.GetVertexType<IVertexType>(
mySecurityToken,
myTransactionToken,
new RequestGetVertexType(myPath.Edges[desiredBELevel].VertexTypeID),
(stats, vertexType) => vertexType);
tempAttr = tempType.GetAttributeDefinition(myPath.Edges[desiredBELevel].AttributeID);
if (tempAttr.Kind != AttributeType.IncomingEdge)
{
return new EdgeKey(tempType.ID, tempAttr.ID);
}
else
{
IIncomingEdgeDefinition incomingEdgeDefinition = tempAttr as IIncomingEdgeDefinition;
return new EdgeKey(incomingEdgeDefinition.RelatedEdgeDefinition.SourceVertexType.ID, incomingEdgeDefinition.RelatedEdgeDefinition.ID);
}
}
/// <summary>
/// This method adds a Node to a Level.
/// </summary>
/// <param name="myNode">The Node that is going to be added</param>
/// <param name="myPath">The place where the node is going to be added.</param>
private void AddNodeToLevel(IExpressionNode myNode, LevelKey myPath)
{
lock (_Levels)
{
AddEmptyLevel(myPath);
_Levels[myPath.Level].AddNode(myPath, myNode);
}
}
public abstract void AddNode(IVertex myVertex, LevelKey myIDNode, int backwardResolution);
private void DownfillLevelKey(IExpressionGraph aGraph, LevelKey aLevel)
{
lock (aGraph)
{
DownFillStructureOfGraph(aGraph, aLevel);
#region get levelKeys that match
var lowerLevelKeys = ExtractLowerLevelKeys(aLevel.Level - 1, aLevel, aGraph);
#endregion
if (lowerLevelKeys != null)
{
foreach (var aNode in aGraph.Levels[aLevel.Level].ExpressionLevels[aLevel].Nodes)
{
#region update levels that are lower (e.g. 1(current)-->0)
if (lowerLevelKeys != null)
{
UpdateLowerLevels(aNode.Value, aLevel, lowerLevelKeys, aGraph);
}
#endregion
}
}
}
}
public abstract Boolean AddEmptyLevel(LevelKey myLevelKey);
private void DownFillStructureOfGraph(IExpressionGraph anotherGraph, LevelKey levelKey)
{
lock (anotherGraph)
{
if (levelKey.Level > 0)
{
var nextLowerLevel = levelKey.Level - 1;
var nextLowerLevelKey = levelKey.GetPredecessorLevel(_iGraphDB, _securityToken, _transactionToken);
if (anotherGraph.Levels.ContainsKey(nextLowerLevel))
{
if (!anotherGraph.Levels[nextLowerLevel].ExpressionLevels.ContainsKey(nextLowerLevelKey))
{
anotherGraph.Levels[nextLowerLevel].AddEmptyLevelKey(nextLowerLevelKey);
if (nextLowerLevel > 0)
{
DownFillStructureOfGraph(anotherGraph, nextLowerLevelKey.GetPredecessorLevel(_iGraphDB, _securityToken, _transactionToken));
}
}
}
else
{
anotherGraph.Levels.Add(nextLowerLevel, new ExpressionLevel());
anotherGraph.Levels[nextLowerLevel].AddEmptyLevelKey(nextLowerLevelKey);
if (nextLowerLevel > 0)
{
DownFillStructureOfGraph(anotherGraph, nextLowerLevelKey);
}
}
}
}
}
public abstract IEnumerable<IVertex> Select(LevelKey myLevelKey, IVertex mySourceVertex = null, Boolean generateLevel = true);
private void ExtendGraphUp(LevelKey startLevelKey, LevelKey endLevelKey, IExpressionGraph aGraph)
{
if (startLevelKey != endLevelKey)
{
var nextHigherLevelKeys = (from aHigherExpressionLevel in aGraph.Levels[startLevelKey.Level + 1].ExpressionLevels
where IsValidLevelKeyNeighbourship(startLevelKey, aHigherExpressionLevel.Key)
select aHigherExpressionLevel.Key);
var nextHigherLevelKey = (from aLowerExpressionLevel in nextHigherLevelKeys where IsValidLevelKeyNeighbourship(aLowerExpressionLevel, endLevelKey) select aLowerExpressionLevel).FirstOrDefault();
IVertex currentDBObject = null;
EdgeKey myCurrentForwardEdgekey = nextHigherLevelKey.Edges[startLevelKey.Level];
IVertexType currentType = _iGraphDB.GetVertexType<IVertexType>(
_securityToken,
_transactionToken,
new RequestGetVertexType(myCurrentForwardEdgekey.VertexTypeID),
(stats, vertexType) => vertexType);
IAttributeDefinition interestingAttribute = currentType.GetAttributeDefinition(myCurrentForwardEdgekey.AttributeID);
//find out whats the real type of the referenced objects
var typeOfReferencedObjects = GetTypeOfAttribute(currentType, interestingAttribute);
//Extend graph
foreach (var aNode in aGraph.Levels[startLevelKey.Level].ExpressionLevels[startLevelKey].Nodes)
{
currentDBObject = aNode.Value.GetIVertex();
if (currentDBObject != null)
{
//there is no need to extend the graph if there is no IVertex available
switch (interestingAttribute.Kind)
{
case AttributeType.IncomingEdge:
var incomingAttribute = (IIncomingEdgeDefinition)interestingAttribute;
if (currentDBObject.HasIncomingVertices(incomingAttribute.RelatedEdgeDefinition.SourceVertexType.ID, incomingAttribute.RelatedEdgeDefinition.ID))
{
foreach (var aIncomingVertex in currentDBObject.GetIncomingVertices(incomingAttribute.RelatedEdgeDefinition.SourceVertexType.ID, incomingAttribute.RelatedEdgeDefinition.ID))
{
//add backwardEdge to node (and itself)
aGraph.Levels[nextHigherLevelKey.Level].AddNodeAndBackwardEdge(nextHigherLevelKey, aIncomingVertex, startLevelKey.LastEdge, aNode.Key, null, null);
//recursion
ExtendGraphUp(nextHigherLevelKey, endLevelKey, aGraph);
aNode.Value.AddForwardEdge(myCurrentForwardEdgekey, GenerateVertexInfoFromLevelKeyAndVertexID(aIncomingVertex.VertexTypeID, aIncomingVertex.VertexID), null);
}
}
break;
case AttributeType.OutgoingEdge:
var outgoingEdgeAttribute = (IOutgoingEdgeDefinition)interestingAttribute;
if (currentDBObject.HasOutgoingEdge(outgoingEdgeAttribute.ID))
{
foreach (var aOutgoingVertex in currentDBObject.GetOutgoingEdge(outgoingEdgeAttribute.ID).GetTargetVertices())
{
//add backwardEdge to node (and itself)
aGraph.Levels[nextHigherLevelKey.Level].AddNodeAndBackwardEdge(nextHigherLevelKey, aOutgoingVertex, startLevelKey.LastEdge, aNode.Key, null, null);
//recursion
ExtendGraphUp(nextHigherLevelKey, endLevelKey, aGraph);
aNode.Value.AddForwardEdge(myCurrentForwardEdgekey, GenerateVertexInfoFromLevelKeyAndVertexID(aOutgoingVertex.VertexTypeID, aOutgoingVertex.VertexID), null);
}
}
break;
case AttributeType.Property:
default:
break;
}
}
}
}
}
public abstract Boolean IsGraphRelevant(LevelKey myLevelKey, IVertex mySourceVertex);
public LevelKey AddLevelKey(LevelKey myLevelKey2, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
if ((this.Edges == null || this.Edges.Count == 0) && (myLevelKey2.Edges == null || myLevelKey2.Edges.Count == 0))
return new LevelKey();
else if (this.Edges == null || this.Edges.Count == 0)
return new LevelKey(myLevelKey2.Edges, myGraphDB, mySecurityToken, myTransactionToken);
else if (myLevelKey2.Edges == null || myLevelKey2.Edges.Count == 0)
return new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken);
if (this.Level == 0 && myLevelKey2.Level == 0)
{
#region both are level 0 (User/null)
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
else
return new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken);
#endregion
}
else if (this.Level == 0)
{
#region one of them is level 0 - so we can just skip this level: User/null + User/Friends == User/Friends
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
else
return new LevelKey(myLevelKey2.Edges, myGraphDB, mySecurityToken, myTransactionToken); // just return the other level
#endregion
}
else if (myLevelKey2.Level == 0)
{
#region one of them is level 0 - so we can just skip this level: User/null + User/Friends == User/Friends
if (this.Edges[0].VertexTypeID != myLevelKey2.Edges[0].VertexTypeID) // if the types are different then something is really wrong
throw new InvalidLevelKeyOperationException(this, myLevelKey2, "+");
else
return new LevelKey(this.Edges, myGraphDB, mySecurityToken, myTransactionToken); // just return the other level
#endregion
}
var edges = new List<EdgeKey>(this.Edges);
edges.AddRange(myLevelKey2.Edges);
return new LevelKey(edges, myGraphDB, mySecurityToken, myTransactionToken);
}
public abstract void GatherEdgeWeight(LevelKey StartLevel, LevelKey EndLevel);
public Boolean Equals(LevelKey p)
{
// If parameter is null return false:
if ((object)p == null)
{
return false;
}
if (this.Level != p.Level)
{
return false;
}
for (int i = 0; i < Edges.Count; i++)
{
if (this.Edges[i] != p.Edges[i])
{
return false;
}
}
return true;
}
public LevelKey RemoveLevelKey(LevelKey myOtherLevelKey, IGraphDB myGraphDB, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
if (this.Level < myOtherLevelKey.Level)
throw new ArgumentException("level of left (" + this.Level + ") operand is lower than right (" + myOtherLevelKey.Level + ") operand:", "myOtherLevelKey");
if (!this.StartsWith(myOtherLevelKey, true))
throw new ArgumentException("left operand level does not starts with right operand level");
if (myOtherLevelKey.Level == 0)
return this;
if (this.Level == myOtherLevelKey.Level)
return new LevelKey(this.Edges[0].VertexTypeID, myGraphDB, mySecurityToken, myTransactionToken);
var edgeList = new List<EdgeKey>(this.Edges);
return new LevelKey(this.Edges.Skip(myOtherLevelKey.Edges.Count), myGraphDB, mySecurityToken, myTransactionToken);
}
public bool StartsWith(LevelKey myLevel)
{
if (myLevel.Level > Level)
throw new ArgumentException(myLevel + " is greater than " + Level);
for (Int32 i = 0; i < myLevel.Level; i++)
{
if (myLevel.Edges[i].VertexTypeID != Edges[i].VertexTypeID)
return false;
}
return true;
}
public ExpressionLevelEntry(LevelKey myCorrespondingLevelKey, Dictionary <VertexInformation, IExpressionNode> myObjects)
{
_Objects = myObjects;
_CorrespondingLevelKey = myCorrespondingLevelKey;
}
public bool StartsWith(LevelKey myLevel, Boolean IncludingAttrs)
{
if (!IncludingAttrs)
return StartsWith(myLevel);
if (myLevel.Level > Level)
throw new ArgumentException(myLevel + " is greater than " + Level);
for (Int32 i = 0; i < myLevel.Level; i++)
{
if (myLevel.Edges[i].VertexTypeID != Edges[i].VertexTypeID || myLevel.Edges[i].AttributeID != Edges[i].AttributeID)
return false;
}
return true;
}
private void AddNodeRecursiveBackward(IVertex myNewVertex, VertexInformation mySourceUUID, LevelKey mySourceLevelKey, LevelKey myNewNodeLevelKey, List<LevelKey> lowerLevelKeys, IExpressionGraph myGraph)
{
lock (myGraph)
{
//took the vertextype id of the levelkey, because it is possible that the vertextypeid of the vertex is something inheritated
VertexInformation node = GenerateVertexInfoFromLevelKeyAndVertexID(myNewVertex.VertexTypeID, myNewVertex.VertexID);
#region add node
//add node and the node's backwardEdge
//in this point we are shure that the level reall exists
if (!myGraph.Levels[myNewNodeLevelKey.Level].ExpressionLevels[myNewNodeLevelKey].Nodes.ContainsKey(node))
{
myGraph.Levels[myNewNodeLevelKey.Level].ExpressionLevels[myNewNodeLevelKey].Nodes.Add(node, new ExpressionNode(myNewVertex, null, node));
}
myGraph.Levels[myNewNodeLevelKey.Level].AddForwardEdgeToNode(myNewNodeLevelKey, node, mySourceLevelKey.LastEdge, mySourceUUID, null);
#endregion
#region recursion
if (lowerLevelKeys != null)
{
UpdateLowerLevels(myGraph.Levels[myNewNodeLevelKey.Level].ExpressionLevels[myNewNodeLevelKey].Nodes[node], myNewNodeLevelKey, lowerLevelKeys, myGraph);
}
#endregion
}
}
public abstract Boolean AddEmptyLevel(LevelKey myLevelKey);
