Best code snippets using com.hp.hpl.jena.graph.Node(Showing top 20 results out of 315)

protected int bindingCount( Node n, Triple o )
  {
  return n.isVariable()   
    ? bc( n, o.getSubject() ) + bc( n, o.getPredicate() ) + bc( n, o.getObject() )
    : 0;
  }
  

/**
 * Validate a triple add to see if it should reinvoke the hook. If so
 * then the inference will be restarted at next prepare time. Incremental
 * re-processing is not yet supported.
 */
public boolean needsRerun(FBRuleInfGraph infGraph, Triple t) {
  return (t.getPredicate().equals(OWL.intersectionOf.asNode()));
}

  @Override
  public boolean bodyCall(Node[] args, int length, RuleContext context) {
    checkArgs(length, context);
    BindingEnvironment env = context.getEnv();
    Triple t = new Triple( Node.createAnon(), Node.createURI("http://jena.hpl.hp.com/example#"), Node.createAnon());
    Node l = Node.createLiteral( LiteralLabelFactory.create(t) );
    return env.bind(args[0], l);
  }
}

/**
  Answer true iff this triple can be compared for sameValueAs by .equals(),
  ie, it is a concrete triple with a non-literal object.
*/
protected final boolean isSafeForEquality( Triple t )
  { return t.isConcrete() && !t.getObject().isLiteral(); }
}

public static DBPropGraph findPropGraphByName( SpecializedGraph graph, String name ) {
  Node myNode = Node.createLiteral( name );
  ClosableIterator<Triple> it = graph.find( null, graphName, myNode, newComplete() );
  
  try {
    if( it.hasNext() )
      return new DBPropGraph( graph, it.next().getSubject());
    return null;
  }
  finally { it.close(); }
}

@Test public void testUpdateScript2()
{
  GraphStore gStore = getEmptyGraphStore() ;
  script(gStore, "update-2.ru") ;
  assertTrue(graphContains(gStore.getGraph(Node.createURI("http://example/g1")),
               new Triple(s,p,NodeFactory.parseNode("123")))) ;
  assertTrue(graphEmpty(gStore.getDefaultGraph())) ;
}

@Override
public int hashCode()
{
  if ( hash == -1 )
  {
    if ( isTriple() )
      hash = asTriple().hashCode() ;
    else
      hash = (subject.hashCode()<<2) ^ path.hashCode() ^ (object.hashCode()<<1) ;
  }
  return hash ;
}
 

private static int getIndex(Triple triple)
{
  String u = triple.getPredicate().getURI() ;
  // Must be _nnn.
  Matcher m = pattern.matcher(u);
  if ( ! m.find() )
    return NOT_FOUND ; 
  String index = m.group(1) ;
  return Integer.parseInt(index) ;
}
 

  @Override
  public int getPartition(WritableTriple key, WritableTriple value, int i) {
    return abs(key.getTriple().getSubject().toString().hashCode()) % i;
  }
}

@Override public ExtendedIterator<Triple> graphBaseFind( TripleMatch m ) 
  {
  Triple t = m.asTriple();
  Node S = t.getSubject(), P = t.getPredicate(), O = t.getObject();
  return 
    S.isConcrete() ? mixedStore.iterator( S, t )
    : P.isConcrete() ? mixedStore.iterator( P, t )
    : O.isURI() || O.isBlank() ? mixedStore.iterator( O, t )
    : mixedStore.iterator( m.asTriple() )
    ; 
  }

public void testRemoveByIterator()
  {
  addTriples( ntS, "x nice a; a nasty b; x nice c" );
  addTriples( ntS, "y nice d; y nasty e; y nice f" );
  Iterator<Triple> it = ntS.iterateAll();
  while (it.hasNext())
    {
    Triple t = it.next();
    if (t.getPredicate().equals( node( "nasty") )) it.remove();
    }
  assertEquals( tripleSet( "x nice a; x nice c; y nice d; y nice f" ), ntS.iterateAll().toSet() );
  }

protected static boolean equalsObjectOK( Triple t )
  { 
  Node o = t.getObject();
  return o.isLiteral() ? o.getLiteralDatatype() == null : true;
  }

/**
  given a triple t, see if it's a reification triple and if so return the internal selector;
  otherwise return null.
*/ 
public ReifierFragmentHandler getFragmentHandler( Triple t )
  {
  Node p = t.getPredicate();
  ReifierFragmentHandler x = selectors.get( p );
  if (x == null || (p.equals( RDF.Nodes.type ) && !t.getObject().equals( RDF.Nodes.Statement ) ) ) return null;
  return x;
  }

@Override
public boolean equals(Object other)
{
  if ( this == other) return true ;
  if ( ! ( other instanceof TriplePath) )
    return false ;
  TriplePath tp = (TriplePath)other ;
  // True if one is true and one is false
  if ( tp.isTriple() ^ this.isTriple() )
    return false ;
  if ( isTriple() )
    return asTriple().equals(tp.asTriple()) ;
  else        
    return subject.equals(tp.subject) && object.equals(tp.object) && path.equals(tp.path) ;
}
 

/**
 * Test case for a bug in retrieving a value like 3.00 from
 * a probe like 3.0
 */
public void testDecimalFind() {
  RDFDatatype dt = XSDDatatype.XSDdecimal;
  Node ns = Node.createURI("x") ;
  Node np = Node.createURI("p") ;
  Node nx1 = Node.createLiteral("0.50", null, dt) ;
  Node nx2 = Node.createLiteral("0.500", null, dt) ;
  Graph graph = Factory.createDefaultGraph() ;
  graph.add(new Triple(ns, np, nx1)) ;
  assertTrue( graph.find(Node.ANY, Node.ANY, nx2).hasNext() );  
}

public void triple(int line, int col, Triple triple)
{
  //Check it's valid triple.
  Node s = triple.getSubject() ;
  Node p = triple.getPredicate() ;
  Node o = triple.getObject() ;
  
  if ( ! ( s.isURI() || s.isBlank() ) )
    throw new TurtleParseException("["+line+", "+col+"] : Error: Subject is not a URI or blank node") ;
  if ( ! p.isURI() )
    throw new TurtleParseException("["+line+", "+col+"] : Error: Predicate is not a URI") ;
  if ( ! ( o.isURI() || o.isBlank() || o.isLiteral() ) ) 
    throw new TurtleParseException("["+line+", "+col+"] : Error: Object is not a URI, blank node or literal") ;
  
  graph.add(triple) ;
}

/**
 * Validate a triple add to see if it should reinvoke the hook. If so
 * then the inference will be restarted at next prepare time. Incremental
 * re-processing is not yet supported but in this case would be useful.
 */
public boolean needsRerun(FBRuleInfGraph infGraph, Triple t) {
  return (t.getPredicate().getURI().startsWith(memberPrefix));
}

@Test public void testUpdateScript5()
{
  GraphStore gStore = getEmptyGraphStore() ;
  script(gStore, "data-2.ru") ;
  
  
  Graph g = GraphFactory.createPlainGraph() ;
  Node b = Node.createAnon() ;
  
  g.add(new Triple(s, p, b)) ;
  g.add(new Triple(b, q, v)) ;
  assertTrue(g.isIsomorphicWith(gStore.getDefaultGraph())) ;
}
 

/**
 * Instantiate a triple pattern against the current environment.
 * This version handles unbound varibles by turning them into bNodes.
 * @param clause the triple pattern to match
 * @param env the current binding environment
 * @return a new, instantiated triple
 */
public Triple instantiate(TriplePattern pattern) {
  Node s = getGroundVersion(pattern.getSubject());
  if (s.isVariable()) s = Node.createAnon();
  Node p = getGroundVersion(pattern.getPredicate());
  if (p.isVariable()) p = Node.createAnon();
  Node o = getGroundVersion(pattern.getObject());
  if (o.isVariable()) o = Node.createAnon();
  return new Triple(s, p, o);
}

public DBPropGraph( SpecializedGraph g, String newSymbolicName, Graph oldProperties) {
  super(g);
  putPropString(graphName, newSymbolicName);
  // only copy user-configurable properties
  Iterator<Triple> it = oldProperties.find( Node.ANY, Node.ANY, Node.ANY);
  while ( it.hasNext() ) {
    Triple t = it.next();
    if ( t.getPredicate().equals(graphName) ||
    t.getPredicate().equals(graphId) ||
    t.getPredicate().equals(stmtTable) ||
    t.getPredicate().equals(reifTable) )
      continue;
    putPropNode((Node_URI)t.getPredicate(),t.getObject());
  }
}