private void CheckOutgoingEdges(IEnumerable <EdgePredefinition> myEdges, IVertexType myVertexType)
{
foreach (var edge in myEdges)
{
var edgeDef = myVertexType.GetOutgoingEdgeDefinition(edge.EdgeName);
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.SingleEdge:
{
CheckSingleEdge(edge, edgeDef.EdgeType);
break;
}
case EdgeMultiplicity.MultiEdge:
{
if (edge.ContainedEdges != null)
{
foreach (var innerEdge in edge.ContainedEdges)
{
CheckSingleEdge(innerEdge, edgeDef.InnerEdgeType);
}
}
break;
}
case EdgeMultiplicity.HyperEdge:
{
break;
}
}
}
}
private Dictionary <IOutgoingEdgeDefinition, Tuple <bool, long> > StringParser(String current_string,
IVertexType vertexType)
{
Dictionary <IOutgoingEdgeDefinition, Tuple <bool, long> > idList = new Dictionary <IOutgoingEdgeDefinition, Tuple <bool, long> >();
bool endFlag = false;
int EndPos = 0;
try
{
do
{
EndPos = current_string.IndexOf(',');
if (EndPos == -1)
{
EndPos = current_string.Length;
endFlag = true;
}
var idString = current_string.Substring(0, EndPos);
var edgeType = vertexType.GetOutgoingEdgeDefinition(idString);
var hasProperty = edgeType.InnerEdgeType.HasProperty("Weight");
long myPropertyID = 0;
if (hasProperty == true)
{
myPropertyID = edgeType.InnerEdgeType.GetPropertyDefinition("Weight").ID;
}
if (!idList.ContainsKey(edgeType))
{
idList.Add(edgeType, Tuple.Create(hasProperty, myPropertyID));
}
if (!endFlag)
{
current_string = current_string.Substring(EndPos + 1);
}
}while (endFlag != true);
}
catch
{
throw new InvalidFunctionParameterException("edgeType", "Object reference not set to an instance of an object.", "null");
}
return(idList);
}
private void CreateEdgeAddDefinitions(
IEnumerable<EdgePredefinition> myOutgoingEdges,
IVertexType myVertexType,
Int64 myTransaction,
SecurityToken mySecurity,
VertexInformation source,
long date,
out IEnumerable<SingleEdgeAddDefinition> outSingleEdges,
out IEnumerable<HyperEdgeAddDefinition> outHyperEdges)
{
outSingleEdges = null;
outHyperEdges = null;
if (myOutgoingEdges == null)
return;
var singleEdges = new Dictionary<String, SingleEdgeAddDefinition>();
var hyperEdges = new Dictionary<String, HyperEdgeAddDefinition>();
foreach (var edgeDef in myOutgoingEdges)
{
var attrDef = myVertexType.GetOutgoingEdgeDefinition(edgeDef.EdgeName);
switch (attrDef.Multiplicity)
{
case EdgeMultiplicity.SingleEdge:
{
var edge = CreateSingleEdgeAddDefinition(myTransaction,
mySecurity,
date,
attrDef.ID,
edgeDef,
attrDef.EdgeType,
source,
attrDef);
if (edge.HasValue)
singleEdges.Add(edgeDef.EdgeName, edge.Value);
}
break;
case EdgeMultiplicity.HyperEdge:
{
break;
}
case EdgeMultiplicity.MultiEdge:
{
var edge = CreateMultiEdgeAddDefinition(myTransaction,
mySecurity,
source,
date,
edgeDef,
attrDef);
if (edge.HasValue)
hyperEdges.Add(attrDef.Name, edge.Value);
}
break;
default:
throw new UnknownDBException("The EdgeMultiplicy enumeration was updated, but not this switch statement.");
}
}
outSingleEdges = singleEdges.Select(x => x.Value);
outHyperEdges = hyperEdges.Select(x => x.Value);
}
private Tuple<long?, String, VertexUpdateDefinition> CreateVertexUpdateDefinition(
IVertex myVertex,
IVertexType myVertexType,
RequestUpdate myUpdate,
IPropertyProvider myPropertyCopy,
Int64 myTransaction,
SecurityToken mySecurity)
{
#region get removes
List<long> toBeDeletedSingle = null;
List<long> toBeDeletedHyper = null;
List<long> toBeDeletedStructured = null;
List<String> toBeDeletedUnstructured = null;
List<long> toBeDeletedBinaries = null;
if (myUpdate.RemovedAttributes != null)
{
#region remove each defined attribute
foreach (var name in myUpdate.RemovedAttributes)
{
if (myVertexType.HasAttribute(name))
{
var attr = myVertexType.GetAttributeDefinition(name);
switch (attr.Kind)
{
case AttributeType.Property:
if ((attr as IPropertyDefinition).IsMandatory)
throw new MandatoryConstraintViolationException(attr.Name);
toBeDeletedStructured = toBeDeletedStructured ?? new List<long>();
toBeDeletedStructured.Add(attr.ID);
break;
case AttributeType.BinaryProperty:
toBeDeletedBinaries = toBeDeletedBinaries ?? new List<long>();
toBeDeletedBinaries.Add(attr.ID);
break;
case AttributeType.IncomingEdge:
//TODO: a better exception here.
throw new Exception("The edges on an incoming edge attribute can not be removed.");
case AttributeType.OutgoingEdge:
switch ((attr as IOutgoingEdgeDefinition).Multiplicity)
{
case EdgeMultiplicity.HyperEdge:
case EdgeMultiplicity.MultiEdge:
toBeDeletedHyper = toBeDeletedHyper ?? new List<long>();
toBeDeletedHyper.Add(attr.ID);
break;
case EdgeMultiplicity.SingleEdge:
toBeDeletedSingle = toBeDeletedSingle ?? new List<long>();
toBeDeletedSingle.Add(attr.ID);
break;
default:
//TODO a better exception here
throw new Exception("The enumeration EdgeMultiplicity was changed, but not this switch statement.");
}
break;
default:
//TODO: a better exception here.
throw new Exception("The enumeration AttributeType was updated, but not this switch statement.");
}
}
else
{
toBeDeletedUnstructured = toBeDeletedUnstructured ?? new List<String>();
toBeDeletedUnstructured.Add(name);
}
}
#endregion
}
if (myUpdate.RemovedUnstructuredProperties != null)
{
#region remove each unstructured property
foreach (var name in myUpdate.RemovedUnstructuredProperties)
{
if ((myVertexType.HasAttribute(name)) && (myVertexType.GetAttributeDefinition(name).Kind == AttributeType.Property))
{
toBeDeletedUnstructured = toBeDeletedUnstructured ?? new List<String>();
toBeDeletedUnstructured.Add(name);
}
}
#endregion
}
#endregion
#region get update definitions
IDictionary<Int64, HyperEdgeUpdateDefinition> toBeUpdatedHyper = null;
IDictionary<Int64, SingleEdgeUpdateDefinition> toBeUpdatedSingle = null;
IDictionary<Int64, IComparable> toBeUpdatedStructured = null;
IDictionary<String, Object> toBeUpdatedUnstructured = null;
IDictionary<Int64, StreamAddDefinition> toBeUpdatedBinaries = null;
long? revision = null;
string edition = myUpdate.UpdatedEdition;
string comment = myUpdate.UpdatedComment;
#region property copy things
if (myPropertyCopy.StructuredProperties != null)
{
toBeUpdatedStructured = new Dictionary<long, IComparable>();
foreach (var prop in myPropertyCopy.StructuredProperties)
{
var propDef = myVertexType.GetPropertyDefinition(prop.Key);
CheckPropertyType(myVertexType.Name, prop.Value, propDef);
toBeUpdatedStructured.Add(propDef.ID, prop.Value);
}
}
toBeUpdatedUnstructured = myPropertyCopy.UnstructuredProperties;
#endregion
#region binary properties
if (myUpdate.UpdatedBinaryProperties != null)
{
foreach (var prop in myUpdate.UpdatedBinaryProperties)
{
var propDef = myVertexType.GetBinaryPropertyDefinition(prop.Key);
toBeUpdatedBinaries = toBeUpdatedBinaries ?? new Dictionary<long, StreamAddDefinition>();
toBeUpdatedBinaries.Add(propDef.ID, new StreamAddDefinition(propDef.ID, prop.Value));
}
}
#endregion
#region collections
if (myUpdate.AddedElementsToCollectionProperties != null || myUpdate.RemovedElementsFromCollectionProperties != null)
{
if (myUpdate.AddedElementsToCollectionProperties != null && myUpdate.RemovedElementsFromCollectionProperties != null)
{
var keys = myUpdate.AddedElementsToCollectionProperties.Keys.Intersect(myUpdate.RemovedElementsFromCollectionProperties.Keys);
if (keys.CountIsGreater(0))
{
//TOTO a better exception here
throw new Exception("You can not add and remove items simultaneously on a collection attribute.");
}
if (myUpdate.AddedElementsToCollectionProperties != null)
{
foreach (var added in myUpdate.AddedElementsToCollectionProperties)
{
var propDef = myVertexType.GetPropertyDefinition(added.Key);
var hasValue = (propDef == null)
? myVertex.HasUnstructuredProperty(added.Key)
: myVertex.HasProperty(propDef.ID);
//if it is not ICollectionWrapper something wrong with deserialization
var extractedValue = (!hasValue)
? null
: (propDef == null)
? myVertex.GetUnstructuredProperty<ICollectionWrapper>(added.Key)
: (ICollectionWrapper)propDef.GetValue(myVertex);
PropertyMultiplicity mult;
if (propDef != null)
{
//check types only for structured properties
foreach (var element in added.Value)
{
CheckPropertyType(myVertexType.Name, element, propDef);
}
mult = propDef.Multiplicity;
}
else
mult = (added.Value is SetCollectionWrapper)
? PropertyMultiplicity.Set
: PropertyMultiplicity.List;
var newValue = CreateNewCollectionWrapper(
(hasValue)
? extractedValue.Union(added.Value)
: added.Value,
mult);
if (propDef == null)
{
toBeUpdatedUnstructured = toBeUpdatedUnstructured ?? new Dictionary<String, object>();
toBeUpdatedUnstructured.Add(added.Key, newValue);
}
else
{
toBeUpdatedStructured = toBeUpdatedStructured ?? new Dictionary<long, IComparable>();
toBeUpdatedStructured.Add(propDef.ID, newValue);
}
}
}
if (myUpdate.RemovedElementsFromCollectionProperties != null)
{
foreach (var remove in myUpdate.RemovedElementsFromCollectionProperties)
{
var propDef = myVertexType.GetPropertyDefinition(remove.Key);
var hasValue = (propDef == null)
? myVertex.HasUnstructuredProperty(remove.Key)
: myVertex.HasProperty(propDef.ID);
//no value, nothing to remove
if (!hasValue)
continue;
//if it is not ICollectionWrapper something wrong with deserialization
var extractedValue = (propDef == null)
? myVertex.GetUnstructuredProperty<ICollectionWrapper>(remove.Key)
: (ICollectionWrapper)propDef.GetValue(myVertex);
PropertyMultiplicity mult = (propDef != null)
? propDef.Multiplicity
: (extractedValue is SetCollectionWrapper)
? PropertyMultiplicity.Set
: PropertyMultiplicity.List;
var newValue = CreateNewCollectionWrapper(extractedValue.Except(remove.Value), mult);
toBeUpdatedStructured.Add(propDef.ID, newValue);
if (propDef == null)
{
toBeUpdatedUnstructured = toBeUpdatedUnstructured ?? new Dictionary<String, object>();
toBeUpdatedUnstructured.Add(remove.Key, newValue);
}
else
{
toBeUpdatedStructured = toBeUpdatedStructured ?? new Dictionary<long, IComparable>();
toBeUpdatedStructured.Add(propDef.ID, newValue);
}
}
}
}
}
#endregion
#region extract vertex properties
#region will be ignored
long vertexID = 0L;
long creationDate = 0L;
long modificationDate = 0L;
#endregion
ExtractVertexProperties(ref edition, ref revision, ref comment, ref vertexID, ref creationDate, ref modificationDate, toBeUpdatedStructured);
#endregion
#region edge magic
if (myUpdate.AddedElementsToCollectionEdges != null ||
myUpdate.RemovedElementsFromCollectionEdges != null ||
myUpdate.UpdateOutgoingEdges != null ||
myUpdate.UpdateOutgoingEdgesProperties != null)
{
VertexInformation source = new VertexInformation(myVertex.VertexTypeID, myVertex.VertexID);
#region update outgoing edges
if (myUpdate.UpdateOutgoingEdges != null)
{
foreach (var edge in myUpdate.UpdateOutgoingEdges)
{
var edgeDef = myVertexType.GetOutgoingEdgeDefinition(edge.EdgeName);
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.SingleEdge:
{
#region SingleEdge
var targets = GetResultingVertexIDs(myTransaction, mySecurity, edge, edgeDef.TargetVertexType);
if (targets == null || !targets.CountIsGreater(0))
{
toBeDeletedSingle = toBeDeletedSingle ?? new List<long>();
toBeDeletedSingle.Add(edgeDef.ID);
}
else if (targets.CountIsGreater(1))
{
throw new Exception("Single edge can not have more than one target.");
}
else
{
ConvertUnknownProperties(edge, edgeDef.EdgeType);
var structured = CreateStructuredUpdate(edge.StructuredProperties, edgeDef.EdgeType);
var unstructured = CreateUnstructuredUpdate(edge.UnstructuredProperties);
toBeUpdatedSingle = toBeUpdatedSingle ?? new Dictionary<long, SingleEdgeUpdateDefinition>();
toBeUpdatedSingle.Add(edgeDef.ID,
new SingleEdgeUpdateDefinition(source,
targets.First(),
edgeDef.EdgeType.ID,
edge.Comment,
structured,
unstructured));
}
#endregion
}
break;
case EdgeMultiplicity.MultiEdge:
{
#region MultiEdge
// Why deleting the edge instances ???
// they will never be inserted inside the update !!!
// After delete the update will be needless because the edges are deleted !!!
//List<SingleEdgeDeleteDefinition> internSingleDelete = null;
//if (myVertex.HasOutgoingEdge(edgeDef.ID))
//{
// internSingleDelete = new List<SingleEdgeDeleteDefinition>();
// foreach (var edgeInstance in myVertex.GetOutgoingHyperEdge(edgeDef.ID).GetTargetVertices())
// {
// internSingleDelete.Add(
// new SingleEdgeDeleteDefinition(source,
// new VertexInformation(edgeInstance.VertexTypeID,
// edgeInstance.VertexID)));
// }
//}
List<SingleEdgeUpdateDefinition> internSingleUpdate = null;
var targets = GetResultingVertexIDs(myTransaction, mySecurity, edge, edgeDef.TargetVertexType);
if (targets != null)
{
foreach (var target in targets)
{
internSingleUpdate = internSingleUpdate ?? new List<SingleEdgeUpdateDefinition>();
internSingleUpdate.Add(new SingleEdgeUpdateDefinition(source, target, edgeDef.InnerEdgeType.ID));
}
}
if (edge.ContainedEdges != null)
{
foreach (var innerEdge in edge.ContainedEdges)
{
targets = GetResultingVertexIDs(myTransaction, mySecurity, innerEdge, edgeDef.TargetVertexType);
if (targets != null && targets.CountIsGreater(0))
{
ConvertUnknownProperties(innerEdge, edgeDef.InnerEdgeType);
var structured = CreateStructuredUpdate(innerEdge.StructuredProperties, edgeDef.InnerEdgeType);
var unstructured = CreateUnstructuredUpdate(innerEdge.UnstructuredProperties);
foreach (var target in targets)
{
internSingleUpdate = internSingleUpdate ?? new List<SingleEdgeUpdateDefinition>();
internSingleUpdate.Add(
new SingleEdgeUpdateDefinition(source,
target,
edgeDef.InnerEdgeType.ID,
innerEdge.Comment,
structured,
unstructured));
}
}
}
}
ConvertUnknownProperties(edge, edgeDef.EdgeType);
var outerStructured = CreateStructuredUpdate(edge.StructuredProperties, edgeDef.EdgeType);
var outerUnstructured = CreateUnstructuredUpdate(edge.UnstructuredProperties);
toBeUpdatedHyper = toBeUpdatedHyper ?? new Dictionary<long, HyperEdgeUpdateDefinition>();
toBeUpdatedHyper.Add(edgeDef.ID,
new HyperEdgeUpdateDefinition(edgeDef.EdgeType.ID,
edge.Comment,
outerStructured,
outerUnstructured,
null,//internSingleDelete,
internSingleUpdate));
#endregion
}
break;
case EdgeMultiplicity.HyperEdge:
break;
default:
throw new Exception("The enumeration EdgeMultiplicity was changed, but not this switch statement.");
}
}
}
#endregion
#region update outgoing edges properties
if (myUpdate.UpdateOutgoingEdgesProperties != null)
{
foreach (var edge in myUpdate.UpdateOutgoingEdgesProperties)
{
var edgeDef = myVertexType
.GetOutgoingEdgeDefinitions(true)
.Where(_ => _.ID.Equals(edge.EdgeTypeID) ||
_.InnerEdgeType.ID.Equals(edge.EdgeTypeID)).FirstOrDefault();
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.SingleEdge:
{
#region SingleEdge
//var targets = GetResultingVertexIDs(myTransaction, mySecurity, edge, edgeDef.TargetVertexType);
//if (targets == null || !targets.CountIsGreater(0))
//{
// toBeDeletedSingle = toBeDeletedSingle ?? new List<long>();
// toBeDeletedSingle.Add(edgeDef.ID);
//}
//else if (targets.CountIsGreater(1))
//{
// throw new Exception("Single edge can not have more than one target.");
//}
//else
//{
// ConvertUnknownProperties(edge, edgeDef.EdgeType);
// var structured = CreateStructuredUpdate(edge.StructuredProperties, edgeDef.EdgeType);
// var unstructured = CreateUnstructuredUpdate(edge.UnstructuredProperties);
// toBeUpdatedSingle = toBeUpdatedSingle ?? new Dictionary<long, SingleEdgeUpdateDefinition>();
// toBeUpdatedSingle.Add(edgeDef.ID,
// new SingleEdgeUpdateDefinition(source,
// targets.First(),
// edgeDef.EdgeType.ID,
// edge.Comment,
// structured,
// unstructured));
//}
#endregion
}
break;
case EdgeMultiplicity.MultiEdge:
{
#region MultiEdge
List<SingleEdgeUpdateDefinition> internSingleUpdate = null;
var targets =
myVertex
.GetOutgoingEdge(edgeDef.ID)
.GetTargetVertices()
.Select(_ => new VertexInformation(_.VertexTypeID,
_.VertexID));
if (targets != null && targets.CountIsGreater(0))
{
var structured = edge.UpdatedStructuredProperties;
var unstructured = edge.UpdatedUnstructuredProperties;
foreach (var target in targets)
{
internSingleUpdate = internSingleUpdate ?? new List<SingleEdgeUpdateDefinition>();
internSingleUpdate.Add(
new SingleEdgeUpdateDefinition(source,
target,
edgeDef.InnerEdgeType.ID,
edge.CommentUpdate,
structured,
unstructured));
}
}
toBeUpdatedHyper = toBeUpdatedHyper ??
new Dictionary<long, HyperEdgeUpdateDefinition>();
if (toBeUpdatedHyper.ContainsKey(edgeDef.ID))
{
var temp = toBeUpdatedHyper[edgeDef.ID];
toBeUpdatedHyper.Remove(edgeDef.ID);
toBeUpdatedHyper.Add(edgeDef.ID,
MergeToBeAddedHyperEdgeUpdates(temp,
internSingleUpdate));
}
else
toBeUpdatedHyper.Add(edgeDef.ID,
new HyperEdgeUpdateDefinition(edgeDef.EdgeType.ID,
null,
null,
null,
null,
internSingleUpdate));
#endregion
}
break;
case EdgeMultiplicity.HyperEdge:
break;
default:
throw new Exception("The enumeration EdgeMultiplicity was changed, but not this switch statement.");
}
}
}
#endregion
#region update AddedElementsToCollectionEdges
if (myUpdate.AddedElementsToCollectionEdges != null)
{
foreach (var hyperEdge in myUpdate.AddedElementsToCollectionEdges)
{
var edgeDef = myVertexType.GetOutgoingEdgeDefinition(hyperEdge.Key);
if (edgeDef == null)
//TODO a better exception here
throw new Exception("edge attribute not defined.");
if (edgeDef.Multiplicity == EdgeMultiplicity.SingleEdge)
//TODO a better exception here
throw new Exception("Add edges is only defined on hyper/multi edges.");
var edgeTypeID = edgeDef.ID;
StructuredPropertiesUpdate structuredUpdate;
UnstructuredPropertiesUpdate unstructuredUpdate;
IEnumerable<SingleEdgeUpdateDefinition> singleUpdate;
CheckIfToBeAddedElementAlreadyExist(myVertex,
edgeDef,
hyperEdge.Value,
myTransaction,
mySecurity);
CreateSingleEdgeUpdateDefinitions(source,
myTransaction,
mySecurity,
hyperEdge.Value,
edgeDef,
out structuredUpdate,
out unstructuredUpdate,
out singleUpdate);
toBeUpdatedHyper = toBeUpdatedHyper ?? new Dictionary<long, HyperEdgeUpdateDefinition>();
toBeUpdatedHyper.Add(edgeTypeID, new HyperEdgeUpdateDefinition(edgeTypeID, null, structuredUpdate, unstructuredUpdate, null, singleUpdate));
}
}
#endregion
#region update RemovedElementsFromCollectionEdges
if (myUpdate.RemovedElementsFromCollectionEdges != null)
{
foreach (var hyperEdge in myUpdate.RemovedElementsFromCollectionEdges)
{
var edgeDef = myVertexType.GetOutgoingEdgeDefinition(hyperEdge.Key);
if (edgeDef == null)
//TODO a better exception here
throw new Exception("Edge attribute not defined.");
if (edgeDef.Multiplicity == EdgeMultiplicity.SingleEdge)
//TODO a better exception here
throw new Exception("Removing edges is only defined on hyper/multi edges.");
var edgeTypeID = edgeDef.ID;
var del = CreateSingleEdgeDeleteDefinitions(source, myTransaction, mySecurity, hyperEdge.Value, edgeDef);
toBeUpdatedHyper = toBeUpdatedHyper ?? new Dictionary<long, HyperEdgeUpdateDefinition>();
toBeUpdatedHyper.Add(edgeTypeID, new HyperEdgeUpdateDefinition(edgeTypeID, null, null, null, del, null));
}
}
#endregion
}
#endregion
#region create updates
var updateSingle = (toBeUpdatedSingle != null || toBeDeletedSingle != null)
? new SingleEdgeUpdate(toBeUpdatedSingle, toBeDeletedSingle)
: null;
var updateHyper = (toBeUpdatedHyper != null || toBeDeletedHyper != null)
? new HyperEdgeUpdate(toBeUpdatedHyper, toBeDeletedHyper)
: null;
var updateStructured = (toBeUpdatedStructured != null || toBeDeletedStructured != null)
? new StructuredPropertiesUpdate(toBeUpdatedStructured, toBeDeletedStructured)
: null;
var updateUnstructured = (toBeUpdatedUnstructured != null || toBeDeletedUnstructured != null)
? new UnstructuredPropertiesUpdate(toBeUpdatedUnstructured, toBeDeletedUnstructured)
: null;
var updateBinaries = (toBeUpdatedBinaries != null || toBeDeletedBinaries != null)
? new BinaryPropertiesUpdate(toBeUpdatedBinaries, toBeDeletedBinaries)
: null;
#endregion
return Tuple.Create(revision,
edition,
new VertexUpdateDefinition(comment,
updateStructured,
updateUnstructured,
updateBinaries,
updateSingle,
updateHyper));
}
private Dictionary<IOutgoingEdgeDefinition, Tuple<bool, long>> StringParser(String current_string,
IVertexType vertexType)
{
Dictionary<IOutgoingEdgeDefinition, Tuple<bool, long>> idList = new Dictionary<IOutgoingEdgeDefinition, Tuple<bool, long>>();
bool endFlag = false;
int EndPos = 0;
try
{
do
{
EndPos = current_string.IndexOf(',');
if (EndPos == -1)
{
EndPos = current_string.Length;
endFlag = true;
}
var idString = current_string.Substring(0, EndPos);
var edgeType = vertexType.GetOutgoingEdgeDefinition(idString);
var hasProperty = edgeType.InnerEdgeType.HasProperty("Weight");
long myPropertyID = 0;
if (hasProperty == true)
{
myPropertyID = edgeType.InnerEdgeType.GetPropertyDefinition("Weight").ID;
}
if (!idList.ContainsKey(edgeType))
idList.Add(edgeType,Tuple.Create(hasProperty,myPropertyID));
if (!endFlag)
current_string = current_string.Substring(EndPos + 1);
}
while (endFlag != true);
}
catch
{
throw new InvalidFunctionParameterException("edgeType", "Object reference not set to an instance of an object.", "null");
}
return idList;
}
private void CheckOutgoingEdges(IEnumerable<EdgePredefinition> myEdges, IVertexType myVertexType)
{
foreach (var edge in myEdges)
{
var edgeDef = myVertexType.GetOutgoingEdgeDefinition(edge.EdgeName);
switch (edgeDef.Multiplicity)
{
case EdgeMultiplicity.SingleEdge:
{
CheckSingleEdge(edge, edgeDef.EdgeType);
break;
}
case EdgeMultiplicity.MultiEdge:
{
if (edge.ContainedEdges != null)
{
foreach (var innerEdge in edge.ContainedEdges)
{
CheckSingleEdge(innerEdge, edgeDef.InnerEdgeType);
}
}
break;
}
case EdgeMultiplicity.HyperEdge:
{
break;
}
}
}
}
private void CheckRemoveOutgoingEdges(RequestAlterVertexType myAlterVertexTypeRequest, IVertexType myVertexType, SecurityToken mySecurityToken, TransactionToken myTransactionToken)
{
if (myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges == null)
return;
#region get the list of incoming edges that will be deleted too
var toBeRemovedIncomingEdgeIDs = new List<long>();
if (myAlterVertexTypeRequest.ToBeRemovedIncomingEdges != null)
toBeRemovedIncomingEdgeIDs.AddRange(
myAlterVertexTypeRequest.ToBeRemovedIncomingEdges.Select(
_ => myVertexType.GetIncomingEdgeDefinition(_).ID));
#endregion
foreach (var aOutgoingEdge in myAlterVertexTypeRequest.ToBeRemovedOutgoingEdges)
{
var attrDef = myVertexType.GetOutgoingEdgeDefinition(aOutgoingEdge);
var vertex = _vertexManager.ExecuteManager.GetVertex((long) BaseTypes.OutgoingEdge, attrDef.ID, null,
null, myTransactionToken, mySecurityToken);
var incomingEdges = vertex.GetIncomingVertices((long) BaseTypes.IncomingEdge,
(long)
AttributeDefinitions.IncomingEdgeDotRelatedEgde);
foreach (var incomingEdge in incomingEdges)
{
if (!toBeRemovedIncomingEdgeIDs.Contains(incomingEdge.VertexID))
{
//TODO a better exception here
throw new Exception(
"The outgoing edge can not be removed, because there are related incoming edges.");
}
}
}
}
private void ProcessOutgoingEdgeRemoval(IEnumerable<string> myToBeRemovedOutgoingEdges, IVertexType vertexType, TransactionToken myTransactionToken, SecurityToken mySecurityToken)
{
foreach (var aOutgoingEdge in myToBeRemovedOutgoingEdges)
{
var outgoingEdgeDefinition = vertexType.GetOutgoingEdgeDefinition(aOutgoingEdge);
_vertexManager.ExecuteManager.VertexStore.RemoveVertex(mySecurityToken, myTransactionToken, outgoingEdgeDefinition.ID, (long)BaseTypes.OutgoingEdge);
}
}
private void PrintAllVerticesInBase(IVertexType vertex_type)
{
var vertices1 = GraphDSServer.GetVertices<IEnumerable<IVertex>>(SecToken,
TransactionID,
new RequestGetVertices("User"),
(statistics, Vertices) => Vertices);
var attrName = vertex_type.GetAttributeDefinition("Name");
var attrFriendsDate = vertex_type.GetOutgoingEdgeDefinition("friends").InnerEdgeType.GetAttributeDefinition("Time");
foreach (var user in vertices1)
foreach (var hyper in user.GetAllOutgoingHyperEdges())
foreach (var edge in hyper.Item2.GetAllEdges())
Console.WriteLine("{0} - {1} Time: {2}",
user.GetPropertyAsString(attrName.ID),
edge.GetTargetVertex().GetPropertyAsString(attrName.ID),
edge.GetPropertyAsString(attrFriendsDate.ID));
}
