mirror of https://gitee.com/bigwinds/arangodb
733 lines
22 KiB
JavaScript
733 lines
22 KiB
JavaScript
/*jshint strict: false */
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief Graph functionality
|
|
///
|
|
/// @file
|
|
///
|
|
/// DISCLAIMER
|
|
///
|
|
/// Copyright 2010-2012 triagens GmbH, Cologne, Germany
|
|
///
|
|
/// Licensed under the Apache License, Version 2.0 (the "License");
|
|
/// you may not use this file except in compliance with the License.
|
|
/// You may obtain a copy of the License at
|
|
///
|
|
/// http://www.apache.org/licenses/LICENSE-2.0
|
|
///
|
|
/// Unless required by applicable law or agreed to in writing, software
|
|
/// distributed under the License is distributed on an "AS IS" BASIS,
|
|
/// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
/// See the License for the specific language governing permissions and
|
|
/// limitations under the License.
|
|
///
|
|
/// Copyright holder is triAGENS GmbH, Cologne, Germany
|
|
///
|
|
/// @author Dr. Frank Celler, Lucas Dohmen
|
|
/// @author Copyright 2011-2012, triAGENS GmbH, Cologne, Germany
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
var is = require("@arangodb/is"),
|
|
propertyKeys = require("@arangodb/util").propertyKeys,
|
|
shallowCopy = require("@arangodb/util").shallowCopy,
|
|
Edge,
|
|
Graph,
|
|
Vertex,
|
|
GraphArray,
|
|
Iterator;
|
|
|
|
|
|
Iterator = function (wrapper, cursor, stringRepresentation) {
|
|
this.next = function next() {
|
|
if (cursor.hasNext()) {
|
|
return wrapper(cursor.next());
|
|
}
|
|
|
|
return undefined;
|
|
};
|
|
|
|
this.hasNext = function hasNext() {
|
|
return cursor.hasNext();
|
|
};
|
|
|
|
this._PRINT = function (context) {
|
|
context.output += stringRepresentation;
|
|
};
|
|
};
|
|
|
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructs a graph arrays
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray = function (len) {
|
|
if (len !== undefined) {
|
|
this.length = len;
|
|
}
|
|
};
|
|
|
|
GraphArray.prototype = new Array(0);
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief map
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.map = function (fun, thisp) {
|
|
var len = this.length;
|
|
var i;
|
|
|
|
if (typeof fun !== "function") {
|
|
throw new TypeError();
|
|
}
|
|
|
|
var res = new GraphArray(len);
|
|
|
|
for (i = 0; i < len; i++) {
|
|
if (this.hasOwnProperty(i)) {
|
|
res[i] = fun.call(thisp, this[i], i, this);
|
|
}
|
|
}
|
|
|
|
return res;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the in vertices
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getInVertex = function () {
|
|
return this.map(function(a) {return a.getInVertex();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the out vertices
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getOutVertex = function () {
|
|
return this.map(function(a) {return a.getOutVertex();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the peer vertices
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getPeerVertex = function (vertex) {
|
|
return this.map(function(a) {return a.getPeerVertex(vertex);});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sets the property
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.setProperty = function (name, value) {
|
|
return this.map(function(a) {return a.setProperty(name, value);});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.edges = function () {
|
|
return this.map(function(a) {return a.edges();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get outbound edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.outbound = function () {
|
|
return this.map(function(a) {return a.outbound();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get inbound edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.inbound = function () {
|
|
return this.map(function(a) {return a.inbound();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the in edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getInEdges = function () {
|
|
var args = arguments;
|
|
return this.map(function(a) {return a.getInEdges.apply(a, args);});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the out edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getOutEdges = function () {
|
|
var args = arguments;
|
|
return this.map(function(a) {return a.getOutEdges.apply(a, args);});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get the edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.getEdges = function () {
|
|
var args = arguments;
|
|
return this.map(function(a) {return a.getEdges.apply(a, args);});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.degree = function () {
|
|
return this.map(function(a) {return a.degree();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of in-edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.inDegree = function () {
|
|
return this.map(function(a) {return a.inDegree();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of out-edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.inDegree = function () {
|
|
return this.map(function(a) {return a.outDegree();});
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the properties
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
GraphArray.prototype.properties = function () {
|
|
return this.map(function(a) {return a.properties();});
|
|
};
|
|
|
|
|
|
Edge = function (graph, properties) {
|
|
this._graph = graph;
|
|
this._id = properties._key;
|
|
this._properties = properties;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getId = function () {
|
|
return this._properties._key;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getLabel = function () {
|
|
return this._properties.$label;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getProperty = function (name) {
|
|
return this._properties[name];
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getPropertyKeys = function () {
|
|
return propertyKeys(this._properties);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.properties = function () {
|
|
return shallowCopy(this._properties);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getInVertex = function () {
|
|
return this._graph.getVertex(this._properties._to);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/EdgeMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getOutVertex = function () {
|
|
return this._graph.getVertex(this._properties._from);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start Docu Block edgeGetPeerVertex
|
|
///
|
|
/// `edge*.getPeerVertex(vertex)`
|
|
///
|
|
/// Returns the peer vertex of the *edge* and the *vertex*.
|
|
///
|
|
/// @EXAMPLES
|
|
///
|
|
/// @EXAMPLE_ARANGOSH_OUTPUT{edgeGetPeerVertex}
|
|
/// ~ db._drop("v");
|
|
/// ~ db._drop("e");
|
|
/// Graph = require("@arangodb/graph-blueprint").Graph;
|
|
/// g = new Graph("example", "v", "e");
|
|
/// v1 = g.addVertex("1");
|
|
/// v2 = g.addVertex("2");
|
|
/// e = g.addEdge(v1, v2, "1-to-2", "knows");
|
|
/// e.getPeerVertex(v1);
|
|
/// ~ Graph.drop("example");
|
|
/// ~ db._drop("v");
|
|
/// ~ db._drop("e");
|
|
/// @END_EXAMPLE_ARANGOSH_OUTPUT
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype.getPeerVertex = function (vertex) {
|
|
if (vertex._properties._id === this._properties._to) {
|
|
return this._graph.getVertex(this._properties._from);
|
|
}
|
|
|
|
if (vertex._properties._id === this._properties._from) {
|
|
return this._graph.getVertex(this._properties._to);
|
|
}
|
|
|
|
return null;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief edge printing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Edge.prototype._PRINT = function (context) {
|
|
if (!this._properties._id) {
|
|
context.output += "[deleted Edge]";
|
|
}
|
|
else if (this._properties._key !== undefined) {
|
|
if (typeof this._properties._key === "string") {
|
|
context.output += "Edge(\"" + this._properties._key + "\")";
|
|
}
|
|
else {
|
|
context.output += "Edge(" + this._properties._key + ")";
|
|
}
|
|
}
|
|
else {
|
|
context.output += "Edge(<" + this._id + ">)";
|
|
}
|
|
};
|
|
|
|
|
|
Vertex = function (graph, properties) {
|
|
this._graph = graph;
|
|
this._id = properties._key;
|
|
this._properties = properties;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/VertexMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.addInEdge = function (out, id, label, data) {
|
|
return this._graph.addEdge(out, this, id, label, data);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/VertexMethods.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.addOutEdge = function (ine, id, label, data) {
|
|
return this._graph.addEdge(this, ine, id, label, data);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.degree = function () {
|
|
return this.getEdges().length;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of in-edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.inDegree = function () {
|
|
return this.getInEdges().length;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of out-edges
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.outDegree = function () {
|
|
return this.getOutEdges().length;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start Docu Block peerGetId
|
|
///
|
|
/// `peer.getId()`
|
|
///
|
|
/// Returns the identifier of the *peer*. If the vertex was deleted, then
|
|
/// *undefined* is returned.
|
|
///
|
|
/// @EXAMPLES
|
|
///
|
|
/// @verbinclude graph-vertex-get-id
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.getId = function () {
|
|
return this._properties._key;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start Docu Block peerGetProperty
|
|
///
|
|
/// `peer.getProperty(edge)`
|
|
///
|
|
/// Returns the property *edge* a *peer*.
|
|
///
|
|
/// @EXAMPLES
|
|
///
|
|
/// @verbinclude graph-vertex-get-property
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.getProperty = function (name) {
|
|
return this._properties[name];
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start Docu Block peerGetPropertyKeys
|
|
///
|
|
/// `peer.getPropertyKeys()`
|
|
///
|
|
/// Returns all propety names a *peer*.
|
|
///
|
|
/// @EXAMPLES
|
|
///
|
|
/// @verbinclude graph-vertex-get-property-keys
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.getPropertyKeys = function () {
|
|
return propertyKeys(this._properties);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start Docu Block peerproperties
|
|
///
|
|
/// `peer.properties()`
|
|
///
|
|
/// Returns all properties and their values of a *peer*
|
|
///
|
|
/// @EXAMPLES
|
|
///
|
|
/// @verbinclude graph-vertex-properties
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype.properties = function () {
|
|
return shallowCopy(this._properties);
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief vertex representation
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Vertex.prototype._PRINT = function (context) {
|
|
if (! this._properties._id) {
|
|
context.output += "[deleted Vertex]";
|
|
}
|
|
else if (this._properties._key !== undefined) {
|
|
if (typeof this._properties._key === "string") {
|
|
context.output += "Vertex(\"" + this._properties._key + "\")";
|
|
}
|
|
else {
|
|
context.output += "Vertex(" + this._properties._key + ")";
|
|
}
|
|
}
|
|
else {
|
|
context.output += "Vertex(<" + this._id + ">)";
|
|
}
|
|
};
|
|
|
|
|
|
Graph = function (name, vertices, edges, waitForSync) {
|
|
this.initialize(name, vertices, edges, waitForSync);
|
|
};
|
|
|
|
|
|
Graph.prototype._prepareEdgeData = function (data, label) {
|
|
var edgeData;
|
|
|
|
if (is.notExisty(data) && is.object(label)) {
|
|
data = label;
|
|
label = null;
|
|
}
|
|
|
|
if (is.notExisty(label) && is.existy(data) && is.existy(data.$label)) {
|
|
label = data.$label;
|
|
}
|
|
|
|
if (is.notExisty(data) || is.noObject(data)) {
|
|
edgeData = {};
|
|
} else {
|
|
edgeData = shallowCopy(data) || {};
|
|
}
|
|
|
|
edgeData.$label = label;
|
|
|
|
return edgeData;
|
|
};
|
|
|
|
Graph.prototype._prepareVertexData = function (data) {
|
|
var vertexData;
|
|
|
|
if (is.notExisty(data) || is.noObject(data)) {
|
|
vertexData = {};
|
|
} else {
|
|
vertexData = shallowCopy(data) || {};
|
|
}
|
|
|
|
return vertexData;
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief get a vertex from the graph, create it if it doesn't exist
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.getOrAddVertex = function (id) {
|
|
var v = this.getVertex(id);
|
|
|
|
if (v === null) {
|
|
v = this.addVertex(id);
|
|
}
|
|
|
|
return v;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/GraphConstructor.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.addEdge = function (out_vertex, in_vertex, id, label, data, waitForSync) {
|
|
var out_vertex_id, in_vertex_id;
|
|
|
|
if (is.string(out_vertex)) {
|
|
out_vertex_id = out_vertex;
|
|
} else {
|
|
out_vertex_id = out_vertex._properties._id;
|
|
}
|
|
|
|
if (is.string(in_vertex)) {
|
|
in_vertex_id = in_vertex;
|
|
} else {
|
|
in_vertex_id = in_vertex._properties._id;
|
|
}
|
|
|
|
return this._saveEdge(id,
|
|
out_vertex_id,
|
|
in_vertex_id,
|
|
this._prepareEdgeData(data, label),
|
|
waitForSync);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// the real docu is in Users/ModuleGraph/GraphConstructor.mdpp
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.addVertex = function (id, data, waitForSync) {
|
|
return this._saveVertex(id, this._prepareVertexData(data), waitForSync);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @brief replaces an existing vertex by ID
|
|
///
|
|
/// @FUN{@FA{graph}.replaceVertex(*peer*, *peer*)}
|
|
///
|
|
/// Replaces an existing vertex by ID
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.replaceVertex = function (id, data) {
|
|
this._replaceVertex(id, data);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @start DocuBlock graphReplaceEdge
|
|
///
|
|
/// `graph.replaceEdge(peer, peer)`
|
|
///
|
|
/// Replaces an existing edge by ID
|
|
/// @end Docu Block
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.replaceEdge = function (id, data) {
|
|
this._replaceEdge(id, data);
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @brief returns the number of vertices
|
|
///
|
|
/// @FUN{@FA{graph}.order()}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.order = function () {
|
|
return this._vertices.count();
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief returns the number of edges
|
|
///
|
|
/// @FUN{@FA{graph}.size()}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.size = function () {
|
|
return this._edges.count();
|
|
};
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// this is no documentation.
|
|
/// @brief empties the internal cache for Predecessors
|
|
///
|
|
/// @FUN{@FA{graph}.emptyCachedPredecessors()}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.emptyCachedPredecessors = function () {
|
|
this.predecessors = {};
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief gets Predecessors for a pair from the internal cache
|
|
///
|
|
/// @FUN{@FA{graph}.getCachedPredecessors(@FA{target}), @FA{source})}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.getCachedPredecessors = function (target, source) {
|
|
var predecessors;
|
|
|
|
if (this.predecessors[target.getId()]) {
|
|
predecessors = this.predecessors[target.getId()][source.getId()];
|
|
}
|
|
|
|
return predecessors;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief sets Predecessors for a pair in the internal cache
|
|
///
|
|
/// @FUN{@FA{graph}.setCachedPredecessors(@FA{target}), @FA{source}, @FA{value})}
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.setCachedPredecessors = function (target, source, value) {
|
|
if (!this.predecessors[target.getId()]) {
|
|
this.predecessors[target.getId()] = {};
|
|
}
|
|
|
|
this.predecessors[target.getId()][source.getId()] = value;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructs a vertex
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.constructVertex = function (data) {
|
|
var id, rev;
|
|
|
|
if (typeof data === "string") {
|
|
id = data;
|
|
} else {
|
|
id = data._id;
|
|
rev = data._rev;
|
|
}
|
|
|
|
var vertex = this._verticesCache[id];
|
|
|
|
if (vertex === undefined || vertex._rev !== rev) {
|
|
var properties = this._vertices.document(id);
|
|
|
|
if (! properties) {
|
|
throw "accessing a deleted vertex";
|
|
}
|
|
|
|
this._verticesCache[id] = vertex = new Vertex(this, properties);
|
|
}
|
|
|
|
return vertex;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief constructs an edge
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype.constructEdge = function (data) {
|
|
var id, rev, edge, properties;
|
|
|
|
if (typeof data === "string") {
|
|
id = data;
|
|
} else {
|
|
id = data._id;
|
|
rev = data._rev;
|
|
}
|
|
|
|
edge = this._edgesCache[id];
|
|
|
|
if (edge === undefined || edge._rev !== rev) {
|
|
properties = this._edges.document(id);
|
|
|
|
if (!properties) {
|
|
throw "accessing a deleted edge";
|
|
}
|
|
|
|
this._edgesCache[id] = edge = new Edge(this, properties);
|
|
}
|
|
|
|
return edge;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
/// @brief graph printing
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
Graph.prototype._PRINT = function (context) {
|
|
context.output += "Graph(\"" + this._properties._key + "\")";
|
|
};
|
|
|
|
|
|
exports.Edge = Edge;
|
|
exports.Graph = Graph;
|
|
exports.Vertex = Vertex;
|
|
exports.GraphArray = GraphArray;
|
|
exports.Iterator = Iterator;
|
|
|
|
|