private static NodeId createNew(NodeIdType type, int v1, long v2) { // Create general NodeId form. return NodeId.createRaw(type, v1, v2); }
@Override public boolean equals(Object other) { if ( this == other ) return true; if ( other == null ) return false; if ( !(other instanceof NodeId) ) return false; NodeId nOther = ((NodeId)other); return equals(nOther, value1, value2); }
@Override public final Node getNodeForNodeId(NodeId id) { Node n = NodeId.extract(id) ; if ( n != null ) return n ; return super.getNodeForNodeId(id) ; }
private Node _retrieveNodeByNodeId(NodeId id) { if ( NodeId.isDoesNotExist(id) ) return null ; if ( NodeId.isAny(id) ) return null ; synchronized (this) { Node n = readNodeFromTable(id) ; return n ; } }
@Override public String toString() { if ( this == NodeDoesNotExist ) return "[DoesNotExist]"; if ( this == NodeIdAny ) return "[Any]"; if ( this == NodeIdInvalid ) return "[Invalid]"; if ( this == NodeIdDefined ) return "[Defined]"; if ( this == NodeIdUndefined ) return "[Undefined]"; if ( this.isInline() ) { String displayName = this.type().toString(); return String.format("[%s 0x%014X]", displayName, value2); } // [64 bits] //return String.format("[%08X-%016X]", value1, value2); return String.format("[0x%16X]", value2); }
private Iterator<Tuple<NodeId>> scan(Iterator<Tuple<NodeId>> iter, Tuple<NodeId> pattern) { Predicate<Tuple<NodeId>> filter = (item) -> { // Check on pattern and item (both in natural order) for ( int i = 0 ; i < tupleLength ; i++ ) { NodeId n = pattern.get(i) ; // The pattern must be null/Any or match the tuple being tested. if ( ! NodeId.isAny(n) ) if ( ! item.get(i).equals(n) ) return false ; } return true ; } ; return Iter.filter(iter, filter) ; }
@Test public void nodeId_special_01() { assertFalse(NodeId.isConcrete(NodeId.NodeDoesNotExist)); assertEquals(NodeIdType.SPECIAL, NodeId.NodeDoesNotExist.type()); }
private void test(String x, Node correct) { Node n = NodeFactoryExtra.parseNode(x) ; NodeId nodeId = NodeId.inline(n) ; assertNotNull("Expected inlining: "+x, nodeId); boolean b = NodeId.hasInlineDatatype(n) ; assertTrue("Converted NodeId but datatype test was false", b) ; Node n2 = NodeId.extract(nodeId) ; assertNotNull("Expected recovery", n2) ; String s = "("+correct.getLiteralLexicalForm()+","+n2.getLiteralLexicalForm()+")" ; assertTrue("Not same value: "+s, correct.sameValueAs(n2)) ; // Term equality. assertEquals("Not same term", correct, n2) ; } }
@Override public boolean containsNode(Node node) { NodeId x = getNodeIdForNode(node) ; return NodeId.isDoesNotExist(x) ; }
@Test public void nodeId_ptr_02() { NodeId nodeId = NodeIdFactory.createPtr(37); assertEquals(NodeIdType.PTR, nodeId.type()); // assertEquals(37L, nodeId.getPtrLo()); // assertEquals(0, nodeId.getPtrHi()); assertEquals(37L, nodeId.getPtrLocation()); }
return null; NodeIdType type = nodeId.type(); if ( type == PTR || type == NodeIdType.SPECIAL) return null; case XSD_DATETIME: { RDFDatatype dt = (type==XSD_DATETIMESTAMP) ? XSDDatatype.XSDdateTimeStamp : XSDDatatype.XSDdateTime; long val = nodeId.getValue2(); String lex = DateTimeNode.unpackDateTime(val); return NodeFactory.createLiteral(lex, dt); long val = nodeId.getValue2(); String lex = DateTimeNode.unpackDate(val); return NodeFactory.createLiteral(lex, XSDDatatype.XSDdate); long val = nodeId.getValue2(); if ( val == 0 ) return NodeConst.nodeFalse;
@Override public final NodeId getNodeIdForNode(Node node) { NodeId nid = NodeId.inline(node) ; if ( nid != null ) return nid ; return super.getNodeIdForNode(node) ; } @Override
private static long encode(NodeId nodeId) { long x = nodeId.value2; switch(nodeId.type()) { case PTR: return x; case XSD_DOUBLE: // XSD_DOUBLE is special. // Set value bit (63) and bit 62 x = DoubleNode62.insertType(x); return x ; default: // Bit 62 is zero - tagt is for doubles. x = BitsLong.pack(x, nodeId.getTypeValue(), 56, 62); // Set the high, value bit. x = BitsLong.set(x, 63); return x; } }
@Test public void nodeId_ptr_03() { NodeId nodeId = NodeIdFactory.createPtr(39); // 64 bit long x = nodeId.getValue2(); long t = BitsLong.unpack(x, 56, 64); assertEquals(0, t); assertEquals(NodeIdType.PTR.type(), t); }
public final boolean isConcrete() { return isConcrete(this); }
@Override protected Node readNodeFromTable(NodeId id) { try { // Paired : [*] long x = id.getPtrLocation(); transport.readPosition(x) ; RDF_Term term = new RDF_Term() ; term.read(protocol) ; Node n = ThriftConvert.convert(term) ; return n ; } catch (TException ex) { throw new TDBException("NodeTableTRDF/Read", ex) ; } catch (RiotThriftException ex) { Log.error(this, "Bad encoding: NodeId = "+id) ; throw ex ; } }
/** Create from a long-encoded value */ /*package*/ static NodeId createRaw(NodeIdType type, long value) { return new NodeId(type, 0, value); }
@Test public void nodeId_special_02() { assertFalse(NodeId.isConcrete(NodeId.NodeIdAny)); assertEquals(NodeIdType.SPECIAL, NodeId.NodeIdAny.type()); }