public IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
if (_uniqueIds && null != id && null != GetEdge(id))
{
throw new ArgumentException(string.Concat("edge with given id already exists: ", id));
}
VerifyNativeElement(outVertex);
VerifyNativeElement(inVertex);
var base_ = _baseGraph.AddEdge(id, ((IdVertex)outVertex).GetBaseVertex(),
((IdVertex)inVertex).GetBaseVertex(), label);
if (_supportEdgeIds)
{
var v = id ?? _edgeIdFactory.CreateId();
if (null != v)
{
base_.SetProperty(Id, v);
}
}
return(new IdEdge(base_, this));
}
public virtual IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
return(VertexKeyIndex.GetIndexedKeys().Contains(key)
? VertexKeyIndex.Get(key, value).Cast <IVertex>()
: new PropertyFilteredIterable <IVertex>(key, value, GetVertices()));
}
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
var vertex = BaseGraph.GetVertex(id);
return(null == vertex ? null : new EventVertex(vertex, this));
}
public IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
if (!(outVertex is BatchVertex) || !(inVertex is BatchVertex))
{
throw new ArgumentException("Given element was not created in this baseGraph");
}
NextElement();
var ov = GetCachedVertex(outVertex.Id);
var iv = GetCachedVertex(inVertex.Id);
_previousOutVertexId = outVertex.Id; //keep track of the previous out vertex id
if (ov != null && iv != null)
{
_currentEdgeCached = _baseGraph.AddEdge(id, ov, iv, label);
if (_edgeIdKey != null && id != null)
{
_currentEdgeCached.SetProperty(_edgeIdKey, id);
}
}
_currentEdge = new BatchEdge(this);
return(_currentEdge);
}
public virtual IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
var idString = id.ToString();
return(InnerVertices.Get(idString));
}
/// <note>
/// Raises an edgeAdded event.
/// </note>
public IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
var outVertexToSet = outVertex;
if (outVertex is EventVertex)
{
outVertexToSet = (outVertex as EventVertex).Vertex;
}
var inVertexToSet = inVertex;
if (inVertex is EventVertex)
{
inVertexToSet = (inVertex as EventVertex).Vertex;
}
if (inVertexToSet == null || outVertexToSet == null)
{
throw new InvalidOperationException();
}
var edge = BaseGraph.AddEdge(id, outVertexToSet, inVertexToSet, label);
OnEdgeAdded(edge);
return(new EventEdge(edge, this));
}
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
if (null == id)
{
throw new ArgumentNullException("id");
}
if (_supportVertexIds)
{
var i = _baseGraph.GetVertices(Id, id);
var iter = i.GetEnumerator();
if (!iter.MoveNext())
{
return(null);
}
var e = iter.Current;
if (iter.MoveNext())
{
throw new InvalidOperationException(string.Concat("multiple vertices exist with id '", id, "'"));
}
return(new IdVertex(e, this));
}
var base_ = _baseGraph.GetVertex(id);
return(null == base_ ? null : new IdVertex(base_, this));
}
public virtual IEdge GetEdge(object id)
{
GraphContract.ValidateGetEdge(id);
var idString = id.ToString();
return(Edges.Get(idString));
}
public virtual void RemoveEdge(IEdge edge)
{
GraphContract.ValidateRemoveEdge(edge);
var outVertex = (TinkerVertex)edge.GetVertex(Direction.Out);
var inVertex = (TinkerVertex)edge.GetVertex(Direction.In);
IEdge removedEdge;
if (null != outVertex && null != outVertex.OutEdges)
{
var e = outVertex.OutEdges.Get(edge.Label);
if (null != e)
{
e.TryRemove(edge.Id.ToString(), out removedEdge);
}
}
if (null != inVertex && null != inVertex.InEdges)
{
var e = inVertex.InEdges.Get(edge.Label);
if (null != e)
{
e.TryRemove(edge.Id.ToString(), out removedEdge);
}
}
EdgeKeyIndex.RemoveElement(edge);
foreach (var idx in GetIndices().Where(t => t.Type == typeof(IEdge)).Cast <TinkerIndex>())
{
idx.RemoveElement(edge);
}
Edges.TryRemove(edge.Id.ToString(), out removedEdge);
}
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
var vertex = BaseGraph.GetVertex(id);
return(null == vertex ? null : new ReadOnlyVertex(this, vertex));
}
public void MergeVertex(TVertex v, EdgeFactory <TVertex, TEdge> edgeFactory)
{
Contract.Requires(GraphContract.InVertexSet(this, v));
Contract.Requires(edgeFactory != null);
// storing edges in local array
var inedges = this.vertexInEdges[v];
var outedges = this.vertexOutEdges[v];
// remove vertex
this.RemoveVertex(v);
// add edges from each source to each target
foreach (var source in inedges)
{
//is it a self edge
if (source.Source.Equals(v))
{
continue;
}
foreach (var target in outedges)
{
if (v.Equals(target.Target))
{
continue;
}
// we add an new edge
this.AddEdge(edgeFactory(source.Source, target.Target));
}
}
}
public virtual IEnumerable <IEdge> GetEdges(string key, object value)
{
GraphContract.ValidateGetEdges(key, value);
if (EdgeKeyIndex.GetIndexedKeys().Contains(key))
{
return(EdgeKeyIndex.Get(key, value).Cast <IEdge>());
}
return(new PropertyFilteredIterable <IEdge>(key, value, GetEdges()));
}
public IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
if (_supportVertexIds && key == Id)
{
throw new ArgumentException(string.Concat("index key ", Id, " is reserved by idInnerTinkerGrapĥ"));
}
return(new IdVertexIterable(_baseGraph.GetVertices(key, value), this));
}
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
IVertex vertex = BaseGraph.GetVertex(id);
if (null == vertex || !IsInPartition(vertex))
{
return(null);
}
return(new PartitionVertex(vertex, this));
}
public IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
var edge = new PartitionEdge(BaseGraph.AddEdge(id,
((PartitionVertex)outVertex).Vertex,
((PartitionVertex)inVertex).Vertex,
label),
this);
edge.SetPartition(_writePartition);
return(edge);
}
private static void AssertGraphsEqual(
IEdgeListGraph <int, Edge <int> > g,
IEdgeListGraph <int, Edge <int> > result)
{
// check equal
Assert.IsTrue(GraphContract.VertexCountEqual(g, result));
Assert.IsTrue(GraphContract.EdgeCountEqual(g, result));
foreach (var v in g.Vertices)
{
Assert.IsTrue(result.ContainsVertex(v));
}
//foreach (var e in g.Edges)
// Assert.IsTrue(result.ContainsEdge(e.Source, e.Target));
}
/// <note>
/// Raises a vertexRemoved event.
/// </note>
public void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
var vertexToRemove = vertex;
if (vertex is EventVertex)
{
vertexToRemove = (vertex as EventVertex).Vertex;
}
var props = vertex.GetProperties();
if (vertexToRemove != null)
{
BaseGraph.RemoveVertex(vertexToRemove);
OnVertexRemoved(vertex, props);
}
}
public virtual void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
foreach (var edge in vertex.GetEdges(Direction.Both))
{
RemoveEdge(edge);
}
VertexKeyIndex.RemoveElement(vertex);
foreach (var idx in GetIndices().Where(t => t.Type == typeof(IVertex)).Cast <TinkerIndex>())
{
idx.RemoveElement(vertex);
}
IVertex removedVertex;
InnerVertices.TryRemove(vertex.Id.ToString(), out removedVertex);
}
/// <note>
/// If the input data are sorted, then out vertex will be repeated for several edges in a row.
/// In this case, bypass cache and instead immediately return a new vertex using the known id.
/// This gives a modest performance boost, especially when the cache is large or there are
/// on average many edges per vertex.
/// </note>
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
if ((_previousOutVertexId != null) && (_previousOutVertexId == id))
{
return(new BatchVertex(_previousOutVertexId, this));
}
var v = RetrieveFromCache(id);
if (v == null)
{
if (_loadingFromScratch)
{
return(null);
}
if (_baseGraph.Features.IgnoresSuppliedIds)
{
Debug.Assert(_vertexIdKey != null);
var iter = _baseGraph.GetVertices(_vertexIdKey, id).GetEnumerator();
if (!iter.MoveNext())
{
return(null);
}
v = iter.Current;
if (iter.MoveNext())
{
throw new ArgumentException(
string.Concat("There are multiple vertices with the provided id in the database: ", id));
}
}
else
{
v = _baseGraph.GetVertex(id);
if (v == null)
{
return(null);
}
}
_cache.Set(v, id);
}
return(new BatchVertex(id, this));
}
public virtual IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
string idString = null;
IEdge edge;
if (null != id)
{
idString = id.ToString();
edge = Edges.Get(idString);
if (null != edge)
{
throw ExceptionFactory.EdgeWithIdAlreadyExist(id);
}
}
else
{
var done = false;
while (!done)
{
idString = GetNextId();
edge = Edges.Get(idString);
if (null == edge)
{
done = true;
}
}
}
edge = new TinkerEdge(idString, outVertex, inVertex, label, this);
Edges.Put(edge.Id.ToString(), edge);
var out_ = (TinkerVertex)outVertex;
var in_ = (TinkerVertex)inVertex;
out_.AddOutEdge(label, edge);
in_.AddInEdge(label, edge);
return(edge);
}
public IEdge AddEdge(object id, IVertex outVertex, IVertex inVertex, string label)
{
GraphContract.ValidateAddEdge(id, outVertex, inVertex, label);
return(_graph.AddEdge(id, outVertex, inVertex, label));
}
public IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
return(_graph.GetVertices(key, value));
}
public void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
_graph.RemoveVertex(vertex);
}
public IVertex GetVertex(object id)
{
GraphContract.ValidateGetVertex(id);
return(_graph.GetVertex(id));
}
public IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
throw RetrievalNotSupported();
}
public void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
throw new InvalidOperationException(ReadOnlyTokens.MutateErrorMessage);
}
public IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
return(new ReadOnlyVertexIterable(this, BaseGraph.GetVertices(key, value)));
}
public void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
VerifyNativeElement(vertex);
_baseGraph.RemoveVertex(((IdVertex)vertex).GetBaseVertex());
}
public void RemoveVertex(IVertex vertex)
{
GraphContract.ValidateRemoveVertex(vertex);
BaseGraph.RemoveVertex(((PartitionVertex)vertex).Vertex);
}
public IEnumerable <IVertex> GetVertices(string key, object value)
{
GraphContract.ValidateGetVertices(key, value);
return(new EventVertexIterable(BaseGraph.GetVertices(key, value), this));
}