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

private String getModelName( Statement s )
  {
  Node o = s.getObject().asNode();
  return o.isLiteral() ? o.getLiteralLexicalForm(): o.getURI();
  }

  @Override
  public boolean accept(Triple t) {
    if (t.getSubject().isLiteral()) return true;
    if (t.getPredicate().isBlank() || t.getPredicate().isLiteral()) return true;
    return false;
  }
} ) );

public void testLiterals()
  {
  assertFalse( "literal nodes aren't blank", Node.createLiteral( L ).isBlank() );
  assertTrue( "literal nodes are literal", Node.createLiteral( L ).isLiteral() );
  assertFalse( "literal nodes aren't variables", Node.createLiteral( L ).isVariable() );
  assertFalse( "literal nodes aren't URIs", Node.createLiteral( L ).isURI() );
  assertEquals( "literal nodes preserve value", Node.createLiteral( L ).getLiteral(), 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 double getDouble()
{ 
  if ( ! isNode() )
    throw new ItemException("Not a node, can't be a double: "+this) ;
  if ( ! getNode().isLiteral() )
    throw new ItemException("Not a literal, can't be a double: "+this) ;
  return ((Number)(getNode().getLiteralValue())).doubleValue() ;
}

/**
 * Return the lexical form of a literal node, error for other node types
 */
protected String getString(Node n, RuleContext context) {
  if (n.isLiteral()) {
    return n.getLiteralLexicalForm();
  } else {
    throw new BuiltinException(this, context, getName() + " takes only literal arguments");
  }
}

/** Use with caution - better to pass in a Node to Label mapper */
static public void output(Writer out, Node node, Prologue prologue)
{
  output(out, node, prologue, SyntaxLabels.createNodeToLabel()) ;
}
 

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

public void testBlanks()
  {
  assertTrue( "anonymous nodes are blank", Node.createAnon().isBlank() );
  assertFalse( "anonymous nodes aren't literal", Node.createAnon().isLiteral() );
  assertFalse( "anonymous nodes aren't URIs", Node.createAnon().isURI() );
  assertFalse( "anonymous nodes aren't variables", Node.createAnon().isVariable() );
  assertEquals( "anonymous nodes have the right id", Node.createAnon(A).getBlankNodeId(), A );
  }
  

protected Node stripSign(Node node)
{
  if ( ! node.isLiteral() ) return node ;
  String lex = node.getLiteralLexicalForm() ;
  String lang = node.getLiteralLanguage() ;
  RDFDatatype dt = node.getLiteralDatatype() ;
  
  if ( ! lex.startsWith("-") && ! lex.startsWith("+") )
    throw new ARQInternalErrorException("Literal does not start with a sign: "+lex) ;
  
  lex = lex.substring(1) ;
  return Node.createLiteral(lex, lang, dt) ;
}
 

public void testURIs()
  {
  assertFalse( "URI nodes aren't blank", Node.createURI( U ).isBlank() );
  assertFalse( "URI nodes aren't literal", Node.createURI( U ).isLiteral() );
  assertFalse( "URI nodes aren't variables", Node.createURI( U ).isVariable() );
  assertTrue( "URI nodes are URIs", Node.createURI( U ).isURI() );
  assertEquals( "URI nodes preserve URI", Node.createURI( U ).getURI(), U );
  }
  

/**
 * Check whether a Node is a numeric (integer) value
 */
public static boolean isNumeric(Node n) {
  return n.isLiteral() && n.getLiteralValue() instanceof Number;
}

/**
  An enhanced node is Literal iff its underlying node is too.
*/
public final boolean isLiteral() {
  return node.isLiteral();
}

public int getLong()
{ 
  if ( ! isNode() )
    throw new ItemException("Not a node, can't be an integer: "+this) ;
  if ( ! getNode().isLiteral() )
    throw new ItemException("Not a literal, can't be a integer: "+this) ;
  return ((Number)(getNode().getLiteralValue())).intValue() ;
}

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