@Override public boolean isValid(String lexicalForm) { return decoratee.isValid(lexicalForm); }
@Override public boolean isValid(String lexicalForm) { return delegate.isValid(lexicalForm); }
@Override public boolean isValid(String lexicalForm) { return delegate.isValid(lexicalForm); }
protected static boolean validateByDatatypeJena(String lexicalForm, RDFDatatype datatype, ErrorHandler handler, long line, long col) { if ( datatype.isValid(lexicalForm) ) return true ; handler.warning("Lexical form '" + lexicalForm + "' not valid for datatype " + xsdDatatypeName(datatype), line, col) ; return false ; }
public static synchronized String validateAgainstDatatype( String value, String datatypeURI ) { if ( ( datatypeURI != null ) && ( datatypeURI.length()>0 ) ) { RDFDatatype datatype = TypeMapper.getInstance().getSafeTypeByName(datatypeURI); if ( datatype == null ) { throw new RuntimeException( datatypeURI + " is not a recognized datatype"); } if ( datatype.isValid(value) ) { return null; } else { // TODO: better way of getting more friendly names for common datatypes if (ddao == null) { ddao = new DatatypeDaoJena(new WebappDaoFactoryJena(ModelFactory.createOntologyModel(OntModelSpec.OWL_MEM))); } Datatype dtype = ddao.getDatatypeByURI(datatypeURI); String dtypeMsg = (dtype != null) ? dtype.getName() : datatypeURI; return " Please correct this value: must be a valid " + dtypeMsg + "."; } } return null; }
/** Convert the lexical form to a canonical form if one of the known datatypes, * otherwise return the node argument. (same object :: {@code ==}) */ public static Node canonicalValue(Node node) { if ( ! node.isLiteral() ) return node ; // Fast-track if ( NodeUtils.isLangString(node) ) return node; if ( NodeUtils.isSimpleString(node) ) return node; if ( ! node.getLiteralDatatype().isValid(node.getLiteralLexicalForm()) ) // Invalid lexical form for the datatype - do nothing. return node; RDFDatatype dt = node.getLiteralDatatype() ; // Datatype, not rdf:langString (RDF 1.1). DatatypeHandler handler = dispatch.get(dt) ; if ( handler == null ) return node ; Node n2 = handler.handle(node, node.getLiteralLexicalForm(), dt) ; if ( n2 == null ) return node ; return n2 ; }
return node ; if ( ! node.getLiteralDatatype().isValid(node.getLiteralLexicalForm()) )
@Override protected NodeValue exec(Node literalNode, Node datatypeNode, FunctionEnv env) { if(literalNode == null || !literalNode.isLiteral()) { throw new ExprEvalException(); } String lex = literalNode.getLiteralLexicalForm(); if(!datatypeNode.isURI()) { throw new ExprEvalException(); } RDFDatatype datatype = TypeMapper.getInstance().getTypeByName(datatypeNode.getURI()); if(datatype == null) { return NodeValue.TRUE; } else { boolean valid = datatype.isValid(lex); return NodeValue.makeBoolean(valid); } } }
@Override protected NodeValue exec(Node literalNode, Node datatypeNode, FunctionEnv env) { if(literalNode == null || !literalNode.isLiteral()) { throw new ExprEvalException(); } String lex = literalNode.getLiteralLexicalForm(); if(!datatypeNode.isURI()) { throw new ExprEvalException(); } RDFDatatype datatype = TypeMapper.getInstance().getTypeByName(datatypeNode.getURI()); if(datatype == null) { return NodeValue.TRUE; } else { boolean valid = datatype.isValid(lex); return NodeValue.makeBoolean(valid); } } }
private static void normalize(String input, String expected) { Node n1 = NodeFactoryExtra.parseNode(input); assertTrue("Invalid lexical form", n1.getLiteralDatatype().isValid(n1.getLiteralLexicalForm())); Node n2 = CanonicalizeLiteral.get().apply(n1); Node n3 = NodeFactoryExtra.parseNode(expected); assertEquals("Different datatype", n3.getLiteralDatatype(), n2.getLiteralDatatype()); assertEquals("Invalid canonicalization (lex)", n3.getLiteralLexicalForm(), n2.getLiteralLexicalForm()); assertEquals("Invalid canonicalization (node)", n3, n2); }