@Override public NodeId getNodeIdForNode(Node node) { return nodeTable.getNodeIdForNode(node) ; }
@Override public Node getNodeForNodeId(NodeId id) { return nodeTable.getNodeForNodeId(id) ; }
@Override public NodeId allocOffset() { return baseTable.allocOffset() ; }
protected static void writeNode(NodeTable nt, Node n) { NodeId nodeId = nt.getAllocateNodeId(n) ; assertNotNull(nodeId) ; assertNotEquals(NodeId.NodeDoesNotExist, nodeId) ; assertNotEquals(NodeId.NodeIdAny, nodeId) ; Node n2 = nt.getNodeForNodeId(nodeId) ; assertEquals(n, n2) ; NodeId nodeId2 = nt.getNodeIdForNode(n) ; assertEquals(nodeId, nodeId2) ; }
private NodeId _idForNode(Node node, boolean allocate) { if ( node == Node.ANY ) return NodeId.NodeIdAny ; // Try once outside the synchronized // (Cache access is thread-safe.) NodeId nodeId = cacheLookup(node) ; if ( nodeId != null ) return nodeId ; synchronized (lock) { // Update two caches inside synchronized. // Check stil valid. nodeId = cacheLookup(node) ; if ( nodeId != null ) return nodeId ; if ( allocate ) nodeId = baseTable.getAllocateNodeId(node) ; else nodeId = baseTable.getNodeIdForNode(node) ; // Ensure caches have it. Includes recording "no such node" cacheUpdate(node, nodeId) ; return nodeId ; } }
protected static void writeBadNode(NodeTable nt, Node badNode) { NodeId id1 = nt.allocOffset() ; try { NodeId nodeId = nt.getAllocateNodeId(badNode) ; fail("Expected exception for bad node: "+badNode) ; } catch (TDBException ex) { } NodeId id2 = nt.allocOffset() ; assertEquals(id1, id2) ; }
private static NodeId findRDFType(NodeTable nodeTable2) { return nodeTable2.getAllocateNodeId(NodeConst.nodeRDFType) ; }
@Override public Iterator<Pair<NodeId, Node>> all() { if ( false ) testForConsistency() ; return baseTable.all() ; }
@Override public synchronized void close() { if ( baseTable == null ) // Already closed (NodeTables can be shared so .close via two routes). return ; baseTable.close() ; node2id_Cache = null ; id2node_Cache = null ; notPresent = null ; baseTable = null ; }
@Override public boolean containsNode(Node node) { return nodeTable.containsNode(node) ; }
protected static void writeNode(NodeTable nt, Node n) { NodeId nodeId = nt.getAllocateNodeId(n) ; assertNotNull(nodeId) ; assertNotEquals(NodeId.NodeDoesNotExist, nodeId) ; assertNotEquals(NodeId.NodeIdAny, nodeId) ; Node n2 = nt.getNodeForNodeId(nodeId) ; assertEquals(n, n2) ; NodeId nodeId2 = nt.getNodeIdForNode(n) ; assertEquals(nodeId, nodeId2) ; }
protected static void writeBadNode(NodeTable nt, Node badNode) { NodeId id1 = nt.allocOffset() ; try { NodeId nodeId = nt.getAllocateNodeId(badNode) ; fail("Expected exception for bad node: "+badNode) ; } catch (TDBException ex) { } NodeId id2 = nt.allocOffset() ; assertEquals(id1, id2) ; }
@Override public NodeId getAllocateNodeId(Node node) { return nodeTable.getAllocateNodeId(node) ; }
@Override public Iterator<Pair<NodeId, Node>> all() { return nodeTable.all() ; }
@Override public void close() { nodeTable.close() ; } }
@Override public boolean containsNode(Node node) { //info("containsNodeId("+id+") =>") ; boolean b = nodeTable.containsNode(node) ; info("containsNode("+node+") => "+b) ; return b ; }
@Override public NodeId getNodeIdForNode(Node node) { //info("getNodeIdForNode("+node+") =>") ; NodeId nId = nodeTable.getNodeIdForNode(node) ; info("getNodeIdForNode("+node+") => "+nId) ; return nId ; }
private static Quad quad(NodeTable nodeTable, NodeId g, NodeId s, NodeId p, NodeId o) { Node gNode = nodeTable.getNodeForNodeId(g) ; Node sNode = nodeTable.getNodeForNodeId(s) ; Node pNode = nodeTable.getNodeForNodeId(p) ; Node oNode = nodeTable.getNodeForNodeId(o) ; return new Quad(gNode, sNode, pNode, oNode) ; }
@Override public NodeId allocOffset() { return nodeTable.allocOffset() ; }
@Override public NodeId getAllocateNodeId(Node node) { //info("getAllocateNodeId("+node+") =>") ; NodeId nId = nodeTable.getAllocateNodeId(node) ; info("getAllocateNodeId("+node+") => "+nId) ; return nId ; }