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

ReificationCache lookup(Node stmtURI) {
  for (int i = 0; i < cache.length; i++) {
    if (inUse[i] && (cache[i].getStmtURI().equals( stmtURI )))
      return cache[i];
  }
  return null;
}

  @Override
  public boolean doCheck( Node n, EnhGraph g ) {
    return n.equals( RDF.nil.asNode() )  ||
        g.asGraph().contains( n, RDF.type.asNode(), DAML_OIL.Ontology.asNode() );
  }
}

  @Override
  public boolean doCheck( Node n, EnhGraph g ) {
    for (Iterator<Resource> i = ((OntModel) g).getProfile().getAnnotationProperties();  i.hasNext(); ) {
      if (i.next().asNode().equals( n )) {
        // a built-in annotation property
        return true;
      }
    }
    return g.asGraph().contains( n, RDF.type.asNode(), OWL.AnnotationProperty.asNode() );
  }
}

  public boolean mightBeEqual(SomeResource r) {
    if (r!=null && (r instanceof FixedResource)) {
      FixedResource f = (FixedResource)r;
      return hash == f.hash && node.equals(f.node); // PURE SYNTAX
    } else {
      return false;
    }
  }
}

public void testFloatVsDouble()
  {
  Node A = NodeCreateUtils.create( "'1'xsd:float" );
  Node B = NodeCreateUtils.create( "'1'xsd:double" );
  assertFalse( A.equals( B ) );
  assertFalse( A.sameValueAs( B ) );
  assertFalse( B.sameValueAs( A ) );
  assertFalse( A.matches( B ) );
  assertFalse( B.matches( A ) );
  }

@Override
public boolean equalTo(Op other, NodeIsomorphismMap labelMap)
{
  if (other == this) return true;
  if ( ! (other instanceof OpProcedure) ) return false ;
  OpProcedure proc = (OpProcedure)other ;
  
  if ( ! procId.equals(proc.procId) ) return false ;
  if ( ! args.equals(proc.args) ) return false ;
  
  return getSubOp().equalTo(proc.getSubOp(), labelMap) ;
}

@Override
public boolean equals(Object other)
{
  // This is the equality condition Jena uses - lang tags are different by case. 
  if ( this == other ) return true ;
  if ( ! ( other instanceof NodeValue ) )
    return false ;
  NodeValue nv = (NodeValue)other ;
  return asNode().equals(nv.asNode()) ;
  // Not NodeFunctions.sameTerm (which smooshes language tags by case
}

public void testCreateLanguagedLiteralEN2()
  {
  Node n1 = NodeCreateUtils.create( "'chat'en-UK" );
  Node n2 = NodeCreateUtils.create( "'chat'EN-UK" );
  assertTrue( n1.sameValueAs(n2) ) ;
  assertFalse( n1.equals(n2) ) ;
  }    

@Override
public boolean equalTo(Element el2, NodeIsomorphismMap isoMap)
{
  if ( el2 == null ) return false ;
  if ( ! ( el2 instanceof ElementFetch ) ) 
    return false ;
  ElementFetch g2 = (ElementFetch)el2 ;
  if ( ! this.getFetchNode().equals(g2.getFetchNode()) )
    return false ;
  return true ;
}

@Override public ExtendedIterator<Triple> find( TripleMatch tm ) 
  {
  if (tm.getMatchPredicate().equals( node( "eg:p2" ) )) count[0] += 1;
  return super.find( tm ); 
  }
};

/**
   Answer true iff both <code>a</code> and <code>b</code> are ANY wildcards
   or are null (legacy). 
*/
private boolean bothANY( Node a, Node b )
  { return (a == null || a.equals( Node.ANY )) && (b == null || b.equals( Node.ANY )); }

/**
 * Test that two nodes are semantically equivalent.
 * In some cases this may be the same as equals, in others
 * equals is stricter. For example, two xsd:int literals with
 * the same value but different language tag are semantically
 * equivalent but distinguished by the java equality function
 * in order to support round-tripping.
 * <p>Default implementation is to use equals, subclasses should
 * override this.</p>
 */
public boolean sameValueAs(Object o) 
  { return equals( o ); }

  @Override
  public boolean doCheck( Node n, EnhGraph g ) {
    return n.equals( DAML_OIL.nil.asNode() )  ||
        g.asGraph().contains( n, RDF.type.asNode(), DAML_OIL.List.asNode() );
  }
}

/** Helper - equality override on nodes */
private boolean nodeEqual(Node n1, Node n2) {
  if ((n1 instanceof Node_RuleVariable) && (n2 instanceof Node_RuleVariable)) {
    return true;
  } else {
    return n1.equals(n2);
  }
}
  

/** Default, concrete graph (either generated or explicitly named) -- not triple-in-quad*/
public static boolean isUnionGraph(Node node)
{
  return unionGraph.equals(node) ; 
}