/** Create a Context from content of st:param */
public Context process() {
Entity ent = g.getEdges(Context.STL_PARAM).iterator().next();
if (ent == null) {
return new Context();
}
return process(ent.getNode(1));
}
int compare(Entity ent, Node n1, Node n2) {
int res = nodeCompare(getNode(ent, index), n1);
if (res == 0 && n2 != null) {
res = nodeCompare(ent.getNode(other), n2);
}
return res;
}
int compare(Entity ent, int n1, int n2) {
int res = compare(getNode(ent, index).getIndex(), n1);
if (res == 0) {
res = compare(ent.getNode(other).getIndex(), n2);
}
return res;
}
void context(Node ctx) {
importer(ctx);
for (Entity ent : g.getEdgeList(ctx)) {
if (!ent.getEdge().getLabel().equals(Context.STL_IMPORT)) {
Node object = ent.getNode(1);
if (object.isBlank()) {
IDatatype list = list(g, object);
if (list != null) {
c.set(ent.getEdge().getLabel(), list);
continue;
}
}
c.set(ent.getEdge().getLabel(), (IDatatype) object.getValue());
}
}
}
/** Written for index = 0 */
public boolean exist(Node pred, Node n1, Node n2) {
List<Entity> list = checkGet(pred);
if (list == null) {
return false;
}
int n;
if (isByIndex()) {
n = find(list, n1.getIndex(), n2.getIndex(), 0, list.size());
} else {
n = find(list, n1, n2, 0, list.size());
}
if (n >= 0 && n < list.size()) {
Entity ent = list.get(n);
if (same(n1, ent.getNode(0)) && same(n2, ent.getNode(1))) {
return true;
}
}
return false;
}
/**
* Create the index of property pred on nth argument It is synchronized on pred hence several
* synGetCheck can occur in parallel on different pred
*/
private List<Entity> synCheckGet(Node pred) {
synchronized (pred) {
ArrayList<Entity> list = get(pred);
if (list != null && list.size() == 0) {
List<Entity> std = (List<Entity>) graph.getIndex().getEdges(pred, null);
list.ensureCapacity(std.size());
if (index < 2) {
// we are sure that there are at least 2 nodes
list.addAll(std);
} else
for (Entity ent : std) {
// if additional node is missing: do not index this edge
if (ent.nbNode() > index) {
list.add(ent);
}
}
index(pred);
}
return list;
}
}
public boolean exist(Entity edge) {
if (index != IGRAPH && edge.nbNode() <= index) {
// use case: additional node is not present, do not index on this node
// never happens for subject object and graph
return false;
}
List<Entity> list = getByLabel(edge);
if (list == null) return false;
int i = find(list, edge, 0, list.size());
if (i >= list.size()) {
return false;
}
int res = comp.compare(edge, list.get(i));
return (res == 0);
}
public Entity delete(Entity edge) {
if (index != IGRAPH && edge.nbNode() <= index) {
// use case: additional node is not present, do not index on this node
// never happens for subject object and graph
return null;
}
List<Entity> list = getByLabel(edge);
if (list == null) return null;
Comparator<Entity> cmp = getComp();
int i = find(cmp, list, edge, 0, list.size());
if (i >= list.size()) {
return null;
}
if (graph.hasTag()) {
// if edge have no tag:
// dichotomy may have jump in the middle of the tag list
// find first edge of the list
while (i > 0 && cmp.compare(list.get(i - 1), edge) == 0) {
i--;
}
}
Entity ent = delete(cmp, edge, list, i);
logDelete(ent);
if (graph.hasTag()) {
// delete all occurrences of triple that match edge
// with different tags
Entity res = ent;
while (i < list.size() && res != null) {
res = delete(cmp, edge, list, i);
logDelete(res);
}
}
return ent;
}
public void declare(Entity edge, boolean duplicate) {
List<Entity> list = define(edge.getEdge().getEdgeNode());
if (list.size() > 0) {
add(edge, duplicate);
}
}
/** delete/exist */
List<Entity> getByLabel(Entity e) {
Node pred = graph.getPropertyNode(e.getEdge().getEdgeNode().getLabel());
if (pred == null) return null;
List<Entity> list = get(pred);
return list;
}
// TBD
boolean same(Entity e1, Entity e2) {
return e1.getNode(0).same(e2.getNode(0)) && e1.getNode(1).same(e2.getNode(1));
}
/** noGraph == true => if edge already exists in another graph, do not add edge */
public Entity add(Entity edge, boolean duplicate) {
if (index != IGRAPH && edge.nbNode() <= index) {
// use case: additional node is not present, do not index on this node
// never happens for subject object and graph
return null;
}
List<Entity> list = define(edge.getEdge().getEdgeNode());
Comparator cc = comp;
boolean needTag = index == 0 && graph.needTag(edge);
if (needTag) {
// this edge has no tag yet and it will need onefind
// let's see if there is the same triple (with another tag)
// in this case, we skip the insertion
// otherwise we tag the triple and we insert it
cc = skipTag;
} else if (!duplicate) {
cc = skipGraph;
}
if (isSort(edge)) {
// edges are sorted, check presence by dichotomy
int i = find(cc, list, edge, 0, list.size());
int res = 0;
if (i >= list.size()) {
i = list.size();
} else {
if (index == 0) {
res = cc.compare(edge, list.get(i));
if (res == 0) {
// eliminate duplicate at load time for index 0
count++;
return null;
}
}
}
if (needTag) {
tag(edge);
}
if (onInsert(edge)) {
list.add(i, edge);
logInsert(edge);
} else {
return null;
}
} else {
// edges are not already sorted (load time)
// add all edges, duplicates will be removed later when first query occurs
if (onInsert(edge)) {
list.add(edge);
logInsert(edge);
} else {
return null;
}
}
// complete(edge);
return edge;
}
Node getNode(Entity ent, int n) {
if (n == IGRAPH) {
return ent.getGraph();
}
return ent.getNode(n);
}
void add(Entity ent) {
Edge edge = ent.getEdge();
for (int i = 0; i < edge.nbNode(); i++) {
add(ent.getGraph(), edge.getNode(i));
}
}