public ServiceOutgoingEdgeDefinition(IOutgoingEdgeDefinition myOutgoingEdgeDefinition)
: base(myOutgoingEdgeDefinition)
{
this.EdgeType = new ServiceEdgeType(myOutgoingEdgeDefinition.EdgeType);
this.InnerEdgeType = new ServiceEdgeType(myOutgoingEdgeDefinition.InnerEdgeType);
this.SourceVertexType = new ServiceVertexType(myOutgoingEdgeDefinition.SourceVertexType);
this.TargetVertexType = new ServiceVertexType(myOutgoingEdgeDefinition.TargetVertexType);
this.Multiplicity = ConvertHelper.ToServiceEdgeMultiplicity(myOutgoingEdgeDefinition.Multiplicity);
}
public static ISingleEdge GetSingleEdge(this IOutgoingEdgeDefinition myProperty, IVertex myVertex)
{
if (myProperty == null)
{
throw new NullReferenceException();
}
return(myVertex.GetOutgoingSingleEdge(myProperty.ID));
}
public static bool HasValue(this IOutgoingEdgeDefinition myProperty, IVertex myVertex)
{
if (myProperty == null)
{
throw new NullReferenceException();
}
return(myVertex.HasOutgoingEdge(myProperty.ID));
}
public ServiceOutgoingEdgeDefinition(IOutgoingEdgeDefinition myOutgoingEdgeDefinition)
: base(myOutgoingEdgeDefinition)
{
this.EdgeType = (myOutgoingEdgeDefinition.EdgeType == null)
? null : new ServiceEdgeType(myOutgoingEdgeDefinition.EdgeType);
this.InnerEdgeType = (myOutgoingEdgeDefinition.InnerEdgeType == null)
? null : new ServiceEdgeType(myOutgoingEdgeDefinition.InnerEdgeType);
this.SourceVertexType = (myOutgoingEdgeDefinition.SourceVertexType == null)
? null : new ServiceVertexType(myOutgoingEdgeDefinition.SourceVertexType);
this.TargetVertexType = (myOutgoingEdgeDefinition.TargetVertexType == null)
? null : new ServiceVertexType(myOutgoingEdgeDefinition.TargetVertexType);
this.Multiplicity = ConvertHelper.ToServiceEdgeMultiplicity(myOutgoingEdgeDefinition.Multiplicity);
}
private SingleEdgeAddDefinition? CreateSingleEdgeAddDefinition(
Int64 myTransaction,
SecurityToken mySecurity,
long date,
long myAttributeID,
EdgePredefinition edgeDef,
IEdgeType myEdgeType,
VertexInformation source,
IOutgoingEdgeDefinition attrDef)
{
AddDefaultPropertiesToEdgePredefinition(ref edgeDef, attrDef, date);
var vertexIDs = GetResultingVertexIDs(myTransaction,
mySecurity,
edgeDef,
attrDef.TargetVertexType);
if (vertexIDs == null)
return null;
CheckTargetVertices(attrDef.TargetVertexType, vertexIDs);
//adds the basic attributes like CreationDate, ModificationDate ... to the structured properties
AddDefaultValues(ref edgeDef, myEdgeType);
return new SingleEdgeAddDefinition(myAttributeID,
myEdgeType.ID,
source,
vertexIDs.First(),
edgeDef.Comment,
date,
date,
ConvertStructuredProperties(edgeDef, myEdgeType),
edgeDef.UnstructuredProperties);
}
/// <summary>
/// Creates SingleEdgeAddDefintions to create single edges.
/// </summary>
/// <param name="myTransaction">TransactionID</param>
/// <param name="mySecurity">SecurityToken</param>
/// <param name="myDate">Actual DateTime in long.</param>
/// <param name="vertexIDs"></param>
/// <param name="edgeDef">The EdgePredefnintion.</param>
/// <param name="attrDef">The attribute defintion of the outgoing egde.</param>
/// <param name="mySource">The source of the edge.</param>
/// <returns></returns>
private IEnumerable<SingleEdgeAddDefinition> CreateContainedEdges(
Int64 myTransaction,
SecurityToken mySecurity,
long myDate,
IEnumerable<VertexInformation> vertexIDs,
EdgePredefinition edgeDef,
IOutgoingEdgeDefinition attrDef,
VertexInformation mySource)
{
if ((vertexIDs == null || vertexIDs.Count() == 0) &&
(edgeDef.ContainedEdges == null || edgeDef.ContainedEdges.Count() == 0))
return null;
List<SingleEdgeAddDefinition> result = new List<SingleEdgeAddDefinition>();
if (vertexIDs != null)
{
foreach (var vertex in vertexIDs)
{
var toAdd = CreateSingleEdgeAddDefinition(myTransaction,
mySecurity,
myDate,
Int64.MinValue,
edgeDef,
attrDef.InnerEdgeType,
mySource,
attrDef);
if (toAdd.HasValue)
result.Add(toAdd.Value);
}
}
if (edgeDef.ContainedEdges != null)
{
foreach (var edge in edgeDef.ContainedEdges)
{
if (edge.ContainedEdges != null)
//TODO a better exception here
throw new Exception("An edge within a multi edge cannot have contained edges.");
var toAdd = CreateSingleEdgeAddDefinition(myTransaction,
mySecurity,
myDate,
Int64.MinValue,
edge,
attrDef.InnerEdgeType,
mySource,
attrDef);
if (toAdd.HasValue)
result.Add(toAdd.Value);
}
}
return result;
}
/// <summary>
/// Adds edge default properties like CreationDate, ModifactionDate sao. to the predefinition if not already existing
/// </summary>
/// <param name="myPredef">The to be chaged Predefinition</param>
/// <param name="myAttrDef">The outgoing edge definition</param>
/// <param name="myDate">actual date long</param>
private void AddDefaultPropertiesToEdgePredefinition(ref EdgePredefinition myPredef,
IOutgoingEdgeDefinition myAttrDef,
long myDate)
{
foreach (var item in new Dictionary<String, IComparable>
{ { "CreationDate", myDate },
{ "ModificationDate", myDate },
{ "EdgeTypeName", (myAttrDef.InnerEdgeType == null)
? myAttrDef.EdgeType.Name
: myAttrDef.InnerEdgeType.Name },
{ "EdgeTypeID", (myAttrDef.InnerEdgeType == null)
? myAttrDef.EdgeType.ID
: myAttrDef.InnerEdgeType.ID } })
{
if (myPredef.StructuredProperties == null ||
!myPredef.StructuredProperties.ContainsKey(item.Key))
myPredef.AddStructuredProperty(item.Key, item.Value );
}
}
private void CreateSingleEdgeUpdateDefinitions(VertexInformation mySource, Int64 myTransaction, SecurityToken mySecurity, EdgePredefinition myEdge, IOutgoingEdgeDefinition edgeDef, out StructuredPropertiesUpdate outStructuredUpdate, out UnstructuredPropertiesUpdate outUnstructuredUpdate, out IEnumerable<SingleEdgeUpdateDefinition> outSingleUpdate)
{
#region predefine
List<SingleEdgeUpdateDefinition> singleUpdate = new List<SingleEdgeUpdateDefinition>();
#endregion
outStructuredUpdate = null;
outUnstructuredUpdate = null;
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.HyperEdge:
break;
case EdgeMultiplicity.MultiEdge:
var targets = GetResultingVertexIDs(myTransaction, mySecurity, myEdge, edgeDef.TargetVertexType);
if (targets != null)
foreach (var target in targets)
{
singleUpdate.Add(new SingleEdgeUpdateDefinition(mySource, target, Int64.MinValue));
}
if (myEdge.ContainedEdges != null)
{
foreach (var innerEdge in myEdge.ContainedEdges)
{
targets = GetResultingVertexIDs(myTransaction, mySecurity, innerEdge, edgeDef.TargetVertexType);
ConvertUnknownProperties(innerEdge, edgeDef.InnerEdgeType);
var innerStructuredUpdate = CreateStructuredUpdate(innerEdge.StructuredProperties, edgeDef.InnerEdgeType);
var innerUnstructuredUpdate = CreateUnstructuredUpdate(innerEdge.UnstructuredProperties);
if (targets != null)
foreach (var target in targets)
{
singleUpdate.Add(new SingleEdgeUpdateDefinition(mySource, target, Int64.MinValue, null, innerStructuredUpdate, innerUnstructuredUpdate));
}
}
}
outStructuredUpdate = CreateStructuredUpdate(myEdge.StructuredProperties, edgeDef.InnerEdgeType);
outUnstructuredUpdate = CreateUnstructuredUpdate(myEdge.UnstructuredProperties);
break;
default: throw new Exception("The EdgeMultiplicity enumeration was changed, but not this switch statement.");
}
#region return
outSingleUpdate = singleUpdate;
#endregion
}
private HyperEdgeAddDefinition? CreateMultiEdgeAddDefinition(
Int64 myTransaction,
SecurityToken mySecurity,
VertexInformation source,
long date,
EdgePredefinition edgeDef,
IOutgoingEdgeDefinition attrDef)
{
var vertexIDs = GetResultingVertexIDs(myTransaction, mySecurity, edgeDef, attrDef.TargetVertexType);
var contained = CreateContainedEdges(myTransaction, mySecurity, date, vertexIDs, edgeDef, attrDef, source);
if (contained == null)
return null;
return new HyperEdgeAddDefinition(attrDef.ID,
attrDef.EdgeType.ID,
source,
contained,
edgeDef.Comment,
date,
date,
ConvertStructuredProperties(edgeDef, attrDef.InnerEdgeType),
edgeDef.UnstructuredProperties);
}
/// <summary>
/// This method checks if a element inside the to be updated edge already exist,
/// if it exist an exception is thrown.
/// </summary>
/// <param name="myVertex">the to be updated vertex.</param>
/// <param name="myEdgeDef">The edge definition.</param>
/// <param name="myEdgePredef">The update edge predefinition.</param>
/// <param name="myTransaction">TransactionID</param>
/// <param name="mySecurityToken">SecurityToken</param>
private void CheckIfToBeAddedElementAlreadyExist(IVertex myVertex,
IOutgoingEdgeDefinition myEdgeDef,
EdgePredefinition myEdgePredef,
Int64 myTransaction,
SecurityToken mySecurityToken)
{
switch (myEdgeDef.Multiplicity)
{
case EdgeMultiplicity.HyperEdge:
break;
case EdgeMultiplicity.MultiEdge:
var newTargets = GetResultingVertexIDs(myTransaction, mySecurityToken, myEdgePredef, myEdgeDef.TargetVertexType);
var existTargets = myVertex.GetOutgoingHyperEdge(myEdgeDef.ID) == null
? new List<IVertex>()
: myVertex.GetOutgoingHyperEdge(myEdgeDef.ID).GetTargetVertices();
if (newTargets == null)
{
if (myEdgePredef.ContainedEdges != null)
{
foreach (var innerEdge in myEdgePredef.ContainedEdges)
{
newTargets = GetResultingVertexIDs(myTransaction, mySecurityToken, innerEdge, myEdgeDef.TargetVertexType);
foreach (var target in newTargets)
if (existTargets.Any(item => item.VertexID.Equals(target.VertexID) &&
item.VertexTypeID.Equals(target.VertexTypeID)))
throw new VertexAlreadyExistException(target.VertexTypeID, target.VertexID);
}
}
}
else
foreach (var target in newTargets)
if (existTargets.Any(item => item.VertexID.Equals(target.VertexID) &&
item.VertexTypeID.Equals(target.VertexTypeID)))
throw new VertexAlreadyExistException(target.VertexTypeID, target.VertexID);
break;
default: throw new Exception("The EdgeMultiplicity enumeration was changed, but not this switch statement.");
}
}
private IEnumerable<SingleEdgeDeleteDefinition> CreateSingleEdgeDeleteDefinitions(VertexInformation mySource, Int64 myTransaction, SecurityToken mySecurity, EdgePredefinition myEdge, IOutgoingEdgeDefinition edgeDef)
{
List<SingleEdgeDeleteDefinition> result = new List<SingleEdgeDeleteDefinition>();
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.HyperEdge:
break;
case EdgeMultiplicity.MultiEdge:
var targets = GetResultingVertexIDs(myTransaction, mySecurity, myEdge, edgeDef.TargetVertexType);
if (targets != null)
foreach (var target in targets)
{
result.Add(new SingleEdgeDeleteDefinition(mySource, target));
}
foreach (var innerEdge in myEdge.ContainedEdges)
{
targets = GetResultingVertexIDs(myTransaction, mySecurity, innerEdge, edgeDef.TargetVertexType);
if (targets != null)
foreach (var target in targets)
{
result.Add(new SingleEdgeDeleteDefinition(mySource, target));
}
}
break;
default: throw new Exception("The EdgeMultiplicity enumeration was changed, but not this switch statement.");
}
return result;
}
private string GetGraphDDLOfOutgoingEdge(
IOutgoingEdgeDefinition myOutgoingEdgeDefinition,
IVertexType myIVertexType)
{
var stringBuilder = new StringBuilder();
#region build string for edge properties
switch (myOutgoingEdgeDefinition.Multiplicity)
{
//e.g. User
case EdgeMultiplicity.SingleEdge:
stringBuilder.Append(String.Concat(myOutgoingEdgeDefinition.TargetVertexType.Name,
GetGraphDDLOfInnerEdge(myOutgoingEdgeDefinition.InnerEdgeType, myIVertexType)));
break;
//TODO if GQL supports hyper edges, implement this.
case EdgeMultiplicity.HyperEdge:
break;
//e.g. Set<User(e.g. Weighted)>
case EdgeMultiplicity.MultiEdge:
stringBuilder.Append(String.Concat(S_SET,
TERMINAL_LT,
myOutgoingEdgeDefinition.TargetVertexType.Name,
GetGraphDDLOfInnerEdge(myOutgoingEdgeDefinition.InnerEdgeType, myIVertexType),
TERMINAL_GT));
break;
default:
throw new UnknownException(new NotImplementedException("This should never happen"));
}
#endregion
return stringBuilder.ToString();
}
private IEnumerable<SingleEdgeAddDefinition> CreateContainedEdges(
TransactionToken myTransaction,
SecurityToken mySecurity,
long myDate,
IEnumerable<VertexInformation> vertexIDs,
EdgePredefinition edgeDef,
IOutgoingEdgeDefinition attrDef,
VertexInformation mySource)
{
if ((vertexIDs == null || vertexIDs.Count() == 0) && (edgeDef.ContainedEdges == null || edgeDef.ContainedEdges.Count() == 0))
return null;
List<SingleEdgeAddDefinition> result = new List<SingleEdgeAddDefinition>();
if (vertexIDs != null)
{
foreach (var vertex in vertexIDs)
{
//single edges from VertexIDs or expression does not have user properties
//TODO they can have default values
CheckMandatoryConstraint(null, attrDef.InnerEdgeType);
result.Add(new SingleEdgeAddDefinition(Int64.MinValue, attrDef.InnerEdgeType.ID, mySource, vertex, null, myDate, myDate, null, null));
}
}
if (edgeDef.ContainedEdges != null)
{
foreach (var edge in edgeDef.ContainedEdges)
{
if (edge.ContainedEdges != null)
//TODO a better exception here
throw new Exception("An edge within a multi edge cannot have contained edges.");
var toAdd = CreateSingleEdgeAddDefinition(myTransaction, mySecurity, myDate, Int64.MinValue, edge, attrDef.InnerEdgeType, mySource, attrDef.TargetVertexType);
if (toAdd.HasValue)
result.Add(toAdd.Value);
}
}
return result;
}
public void Add(IVertex current_node, double current_distance, UInt64 current_depth, ISingleEdge current_edge, IOutgoingEdgeDefinition edgeType, IVertex father)
{
var id = current_node.VertexID;
_list.Add(id, Tuple.Create(current_node, current_distance, current_depth, Tuple.Create(current_edge, edgeType), father));
_count++;
}
public List <FuncParameter> Execute(IVertexType myTypeOfDBObject, IVertex myDBObject, String myReference, GQLPluginManager myPluginManager, IGraphDB myGraphDB, SecurityToken mySecurityToken, Int64 myTransactionToken)
{
List <FuncParameter> evaluatedParams = new List <FuncParameter>();
int paramCounter = 0;
FuncParameter validationOutput;
//ParameterValue currentParameter;
for (int i = 0; i < Parameters.Count; i++)
{
ParameterValue currentParameter = Function.GetParameter(paramCounter);
if (Parameters[i] is BinaryExpressionDefinition)
{
((BinaryExpressionDefinition)Parameters[i]).Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken);
#region handle BinExp
var calculatedGraphResult = ((BinaryExpressionDefinition)Parameters[i]).Calculon(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, new CommonUsageGraph(myGraphDB, mySecurityToken, myTransactionToken));
var extractedDBOs = calculatedGraphResult.Select(new LevelKey(myTypeOfDBObject.ID, myGraphDB, mySecurityToken, myTransactionToken), null, true);
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, extractedDBOs, null);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
}
else
{
if (Parameters[i] is IDChainDefinition)
{
#region handle IDNode
var tempIDChain = (IDChainDefinition)Parameters[i];
tempIDChain.Validate(myPluginManager, myGraphDB, mySecurityToken, myTransactionToken, false);
if (currentParameter.Value is IAttributeDefinition)
{
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, tempIDChain.LastAttribute, null);
evaluatedParams.Add(validationOutput);
#endregion
}
else
{
if ((tempIDChain.LastAttribute == null) && (tempIDChain.SelectType != TypesOfSelect.None))
{
#region IDNode with asterisk
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, tempIDChain, null);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
}
else
{
switch (tempIDChain.LastAttribute.Kind)
{
case AttributeType.Property:
#region Property
IPropertyDefinition propertyDefinition = (IPropertyDefinition)tempIDChain.LastAttribute;
IComparable value = null;
if (myDBObject.HasProperty(propertyDefinition.ID))
{
value = propertyDefinition.GetValue(myDBObject);
}
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, value, tempIDChain.LastAttribute);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
break;
case AttributeType.IncomingEdge:
#region IncomingEdge
IIncomingEdgeDefinition incomingEdgeAttribute = (IIncomingEdgeDefinition)tempIDChain.LastAttribute;
IEnumerable <IVertex> dbos = new List <IVertex>();
if (myDBObject.HasIncomingVertices(incomingEdgeAttribute.RelatedEdgeDefinition.SourceVertexType.ID, incomingEdgeAttribute.RelatedEdgeDefinition.ID))
{
dbos = myDBObject.GetIncomingVertices(incomingEdgeAttribute.RelatedEdgeDefinition.SourceVertexType.ID, incomingEdgeAttribute.RelatedEdgeDefinition.ID);
}
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, dbos, tempIDChain.LastAttribute);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
break;
case AttributeType.OutgoingEdge:
#region outgoing Edge
IOutgoingEdgeDefinition outgoingEdgeAttribute = (IOutgoingEdgeDefinition)tempIDChain.LastAttribute;
IEnumerable <IVertex> outgoingDBOs = new List <IVertex>();
if (myDBObject.HasOutgoingEdge(outgoingEdgeAttribute.ID))
{
outgoingDBOs = myDBObject.GetOutgoingEdge(outgoingEdgeAttribute.ID).GetTargetVertices();
}
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, outgoingDBOs, tempIDChain.LastAttribute);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
break;
default:
break;
}
}
}
#endregion
}
else
{
#region any other
#region validation
validationOutput = ValidateAndAddParameter(currentParameter, Parameters[i], null);
evaluatedParams.Add(validationOutput);
#endregion
#endregion
}
}
#region increase parameter counter
if (!currentParameter.VariableNumOfParams)
{
paramCounter++;
}
#endregion
}
return(evaluatedParams);
}
public void Add(IVertex current_node, double current_distance, UInt64 current_depth, ISingleEdge current_edge,IOutgoingEdgeDefinition edgeType, IVertex father)
{
var id = current_node.VertexID;
_list.Add(id, Tuple.Create(current_node, current_distance, current_depth, Tuple.Create(current_edge,edgeType), father));
_count++;
}
public void Set(IVertex value, double current_distance, ulong current_depth, ISingleEdge current_edge,IOutgoingEdgeDefinition edgeType, IVertex father)
{
var key = value.VertexID;
_list[key] = Tuple.Create(value, current_distance, current_depth, Tuple.Create(current_edge,edgeType), father);
}
/// <summary>
/// Resolves an attribute
/// </summary>
private IEdgeView ResolveAttributeValue(IOutgoingEdgeDefinition attrDefinition,
IEnumerable<IVertex> attributeValue,
Int64 myDepth,
EdgeList myEdgeList,
IVertex mySourceDBObject,
String reference,
Boolean myUsingGraph,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
#region Get levelKey and UsingGraph
if (myEdgeList.Level == 0)
{
myEdgeList = new EdgeList(new EdgeKey(attrDefinition.RelatedType.ID, attrDefinition.ID));
}
else
{
myEdgeList += new EdgeKey(attrDefinition.RelatedType.ID, attrDefinition.ID);
}
// at some deeper level we could get into graph independend results.
// From this time, we can use the GUID index rather than asking the graph all the time
if (myUsingGraph)
{
myUsingGraph = _ExpressionGraph.IsGraphRelevant(new LevelKey(myEdgeList.Edges,
_graphdb,
mySecurityToken,
myTransactionToken),
mySourceDBObject);
}
#endregion
if (attrDefinition.Multiplicity != EdgeMultiplicity.SingleEdge)
{
#region SetReference attribute -> return new Edge
IEnumerable<IVertexView> resultList = null;
if (myUsingGraph)
{
var dbos = _ExpressionGraph.Select(new LevelKey(myEdgeList.Edges,
_graphdb,
mySecurityToken,
myTransactionToken),
mySourceDBObject,
true);
resultList = GetVertices(mySecurityToken,
myTransactionToken,
attrDefinition.TargetVertexType,
dbos,
myDepth,
myEdgeList,
reference,
myUsingGraph);
}
else
{
resultList = GetVertices(mySecurityToken,
myTransactionToken,
attrDefinition.
TargetVertexType,
attributeValue,
myDepth,
myEdgeList,
reference,
myUsingGraph);
}
return new HyperEdgeView(null, resultList.Select(aTargetVertex => new SingleEdgeView(null, aTargetVertex)));
#endregion
}
else
{
#region Single reference
return new SingleEdgeView(null, LoadAndResolveVertex(mySecurityToken,
myTransactionToken,
attributeValue.FirstOrDefault(),
attrDefinition.SourceVertexType,
myDepth,
myEdgeList,
reference,
myUsingGraph));
#endregion
}
}
/// <summary>
/// Resolves an attribute
/// </summary>
private IEdgeView ResolveAttributeValue(IOutgoingEdgeDefinition attrDefinition,
IEdge myEdge,
Int64 myDepth,
EdgeList myEdgeList,
IVertex mySourceDBObject,
String reference,
Boolean myUsingGraph,
SecurityToken mySecurityToken,
Int64 myTransactionToken)
{
#region Get levelKey and UsingGraph
if (myEdgeList.Level == 0)
{
myEdgeList = new EdgeList(new EdgeKey(attrDefinition.RelatedType.ID,
attrDefinition.ID));
}
else
{
myEdgeList += new EdgeKey(attrDefinition.RelatedType.ID,
attrDefinition.ID);
}
// at some deeper level we could get into graph independend results.
//From this time, we can use the GUID index rather than asking the graph all the time
if (myUsingGraph)
{
myUsingGraph = _ExpressionGraph.IsGraphRelevant(new LevelKey(myEdgeList.Edges,
_graphdb,
mySecurityToken,
myTransactionToken),
mySourceDBObject);
}
#endregion
if (attrDefinition.Multiplicity != EdgeMultiplicity.SingleEdge)
{
#region SetReference attribute -> return new Edge
IEnumerable<SingleEdgeView> resultList = null;
if (myUsingGraph)
{
var dbos = _ExpressionGraph.Select(new LevelKey(myEdgeList.Edges,
_graphdb,
mySecurityToken,
myTransactionToken),
mySourceDBObject,
true).ToList();
//Todo: find a better way to get the edge properties
resultList = GenerateSingleEdgeViews(mySecurityToken,
myTransactionToken,
((IHyperEdge)myEdge)
.GetAllEdges((aSingleEdge) =>
dbos.Contains(aSingleEdge.GetTargetVertex())),
attrDefinition.TargetVertexType,
myDepth,
myEdgeList,
reference,
myUsingGraph,
attrDefinition.InnerEdgeType);
}
else
{
resultList = GenerateSingleEdgeViews(mySecurityToken, myTransactionToken,
((IHyperEdge)myEdge).GetAllEdges(),
attrDefinition.TargetVertexType,
myDepth,
myEdgeList,
reference,
myUsingGraph,
attrDefinition.InnerEdgeType);
}
return new HyperEdgeView(null, resultList);
#endregion
}
else
{
#region Single reference
return GenerateSingleEdgeViews(mySecurityToken, myTransactionToken,
new List<ISingleEdge> { (ISingleEdge)myEdge },
attrDefinition.TargetVertexType,
myDepth,
myEdgeList,
reference,
myUsingGraph,
attrDefinition.InnerEdgeType).FirstOrDefault();
#endregion
}
}
public void Set(IVertex value, double current_distance, ulong current_depth, ISingleEdge current_edge, IOutgoingEdgeDefinition edgeType, IVertex father)
{
var key = value.VertexID;
_list[key] = Tuple.Create(value, current_distance, current_depth, Tuple.Create(current_edge, edgeType), father);
}
