Java NodeFactory.createLiteral方法代码示例

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
public static Node fromThrift(RDF_Term term) {
    if ( term.isSetIri() )
        return NodeFactory.createURI(term.getIri().getIri()) ;

    if ( term.isSetBnode() )
        return NodeFactory.createBlankNode(term.getBnode().getLabel()) ;

    if ( term.isSetLiteral() ) {
        RDF_Literal lit = term.getLiteral() ;
        String lex = lit.getLex() ;
        String dtString = null ;
        if ( lit.isSetDatatype() )
            dtString = lit.getDatatype() ;
        RDFDatatype dt = NodeFactory.getType(dtString) ;

        String lang = lit.getLangtag() ;
        return NodeFactory.createLiteral(lex, lang, dt) ;
    }

    throw new PatchException("No conversion to a Node: "+term.toString()) ;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public NodeValue exec(NodeValue timeStampValue) {

    BigInteger timeStamp;
    if (timeStampValue == null || !timeStampValue.isInteger()) {
        throw new ExprEvalException("The NodeValue " + timeStampValue + " MUST be an integer."
        );
    } else {
        timeStamp = timeStampValue.getInteger();
    }

    if (timeStamp.compareTo(BigInteger.valueOf(Long.MAX_VALUE)) != -1) {
        throw new ExprEvalException("The NodeValue " + timeStamp + " MUST be less than the biggest long value."
        );
    } else if (timeStamp.signum() != 1) {
        throw new ExprEvalException("The NodeValue " + timeStamp + " MUST be positive."
        );
    }

    Timestamp stamp = new Timestamp(timeStamp.longValue());
    Date date = new Date(stamp.getTime());

    Node node = NodeFactory.createLiteral(df.format(date), XSDDatatype.XSDdateTime);
    return new NodeValueNode(node);
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Test
public void testAdd_ReadUser() throws FileNotFoundException {
	Exception exp = null;
	try {
		Quad quad = new Quad(NodeFactory.createURI("http://originalGraph1"), new Triple(NodeFactory.createURI("#electricVehicle3"),
				NodeFactory.createURI("http://www.w3.org/1999/02/22-rdf-syntax-ns#type1"),
				NodeFactory.createLiteral("http://people.aifb.kit.edu/awa/2011/smartgrid/schema/smartgrid#ElectricVehicle1")));
		markLogicDatasetGraphReader.add(quad);
		markLogicDatasetGraphReader.sync();
		assertFalse(markLogicDatasetGraphReader.contains(quad));
	} catch (Exception e) {
		exp = e;

	}
	assertTrue("Should catch ForbiddenUserException ", exp.toString().contains("ForbiddenUserException") && exp != null);

}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public List<TextHit> query(Node property, String qs, int limit) {
	SolrDocumentList solrResults = solrQuery(qs, limit) ;
	List<TextHit> results = new ArrayList<>() ;

	for ( SolrDocument sd : solrResults ) {
		String str = (String)sd.getFieldValue(docDef.getEntityField()) ;
		// log.info("Entity: "+uriStr) ;
		Node n = TextQueryFuncs.stringToNode(str) ;
		Float score = (Float) sd.getFirstValue("score");
		// capture literal value, if stored
		Node literal = null;
		String field = (property != null) ? docDef.getField(property) : docDef.getPrimaryField();
		String value = (String) sd.getFirstValue(field);
		if (value != null) {
			literal = NodeFactory.createLiteral(value); // FIXME: language and datatype
		}
		TextHit hit = new TextHit(n, score.floatValue(), literal);
		results.add(hit) ;
	}

	if ( limit > 0 && results.size() > limit )
		results = results.subList(0, limit) ;

	return results ;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
private Node createNode(Map<String, Object> map) {
    String type = (String)map.get("type") ;
    String lex = (String)map.get("value") ;
    if ( type.equals(IRI) )
        return NodeFactory.createURI(lex);
    else if ( type.equals(BLANK_NODE) )
        return labels.get(null, lex) ;  //??
    else if ( type.equals(LITERAL) ) {
        String lang = (String)map.get("language") ;
        String datatype = (String)map.get("datatype") ;
        if ( Objects.equals(xsdString, datatype) )
            // In RDF 1.1, simple literals and xsd:string are the same.
            // During migration, we prefer simple literals to xsd:strings. 
            datatype = null ;
        if ( lang == null && datatype == null )
            return NodeFactory.createLiteral(lex);
        if ( lang != null )
            return NodeFactory.createLiteral(lex, lang);
        RDFDatatype dt = NodeFactory.getType(datatype) ;
        return NodeFactory.createLiteral(lex, dt);
    } else
        throw new InternalErrorException("Node is not a IRI, bNode or a literal: " + type) ;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
private QueryIterator execFixedSubject(Node nodeURI, Node nodeLocalname, Binding binding, ExecutionContext execCxt)
{
    if ( ! nodeURI.isURI() )
        // Subject bound but not a URI
        return QueryIterNullIterator.create(execCxt) ;

    // Subject is bound and a URI - get the localname as a Node 
    Node localname = NodeFactory.createLiteral(nodeURI.getLocalName()) ;
    
    // Object - unbound variable or a value? 
    if ( ! nodeLocalname.isVariable() )
    {
        // Object bound or a query constant.  Is it the same as the calculated value?
        if ( nodeLocalname.equals(localname) )
            // Same
            return QueryIterSingleton.create(binding, execCxt) ;
        // No - different - no match.
        return QueryIterNullIterator.create(execCxt) ;
    }
    
    // Object unbound variable - assign the localname to it.
    return QueryIterSingleton.create(binding, Var.alloc(nodeLocalname), localname, execCxt) ;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
/**
 * Convert a result from this pattern to an RDF Node
 */
public Node asNode(Object result) {
    // Assumes we have already taken care of multiple valued objects
    if (isURI()) {
        return asURINode(result);
    } else if (result instanceof Node) {
        return (Node) result;
    } else if (result instanceof RDFNodeWrapper) {
        return ((RDFNodeWrapper)result).asRDFNode().asNode();
    } else if (result instanceof String) {
        return NodeFactory.createLiteral( (String)result );
    } else if (result instanceof Number) {
        return ValueNumber.nodeFromNumber( (Number)result );
    } else if (result instanceof Boolean) {
        return NodeFactory.createLiteral( LiteralLabelFactory.createTypedLiteral(result) );
    } else if (result instanceof Value) {
        return ((Value)result).asNode();
    } else {
        // TODO handle dates
    }                
    return null;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public Node convertRow(ConverterProcess config, BindingEnv row, int rowNumber) {
    Node root = NodeFactory.createURI( BASE + rowNumber );
    for (String key : row.keySet()) {
        Node property = NodeFactory.createURI( BASE + key );
        Object value = row.get(key);
        if (value instanceof ValueNumber) {
            if ( ((ValueNumber)value).toNumber().intValue() > 20) {
                throw new NullResult("Value exceeds test threshold of 20");
            }
        }
        Node vnode = NodeFactory.createLiteral( value.toString() );
        config.getOutputStream().triple( new Triple(root, property, vnode) );
    }
    return root;
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
public org.apache.jena.graph.Node build() {
    if (dt != null) {
        RDFDatatype dType = TypeMapper.getInstance().getSafeTypeByName(dt);
        return NodeFactory.createLiteral(value, dType);
    } else if (lang != null && !lang.isEmpty())
        return NodeFactory.createLiteral(value, lang);
    else
        return NodeFactory.createLiteral(value);
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public List<NodeValue> exec(NodeValue cbor, NodeValue jsonpath) {
    if (cbor.getDatatypeURI() != null
            && !cbor.getDatatypeURI().equals(datatypeUri)
            && !cbor.getDatatypeURI().equals("http://www.w3.org/2001/XMLSchema#string")) {
        LOG.warn("The URI of NodeValue1 MUST be"
                + " <" + datatypeUri + "> or"
                + " <http://www.w3.org/2001/XMLSchema#string>. Got <"
                + cbor.getDatatypeURI() + ">. Returning null.");
    }

    Configuration conf = Configuration.builder()
            .options(Option.ALWAYS_RETURN_LIST).build();

    String json = new String(Base64.getDecoder().decode(cbor.asNode().getLiteralLexicalForm().getBytes()));

    try {
        List<Object> values = JsonPath
                .using(conf)
                .parse(json)
                .read(jsonpath.getString());
        List<NodeValue> nodeValues = new ArrayList<>(values.size());
        Gson gson = new Gson();
        for (Object value : values) {
            RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(datatypeUri);
            String jsonstring = gson.toJson(value);
            Node node = NodeFactory.createLiteral(jsonstring, dt);
            NodeValue nodeValue = new NodeValueNode(node);
            nodeValues.add(nodeValue);
        }
        return nodeValues;
    } catch (Exception ex) {
        LOG.debug("No evaluation of " + cbor + ", " + jsonpath, ex);
        throw new ExprEvalException("No evaluation of " + cbor + ", " + jsonpath, ex);
    }
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public List<NodeValue> exec(NodeValue json, NodeValue jsonquery) {
    if (json.getDatatypeURI() != null
            && !json.getDatatypeURI().equals(datatypeUri)
            && !json.getDatatypeURI().equals("http://www.w3.org/2001/XMLSchema#string")) {
        LOG.warn("The URI of NodeValue1 MUST be"
                + " <" + datatypeUri + "> or"
                + " <http://www.w3.org/2001/XMLSchema#string>. Got "
                + json.getDatatypeURI());
    }
    Configuration conf = Configuration.builder()
            .options(Option.ALWAYS_RETURN_LIST).build();

    try {
        List<Object> values = JsonPath
                .using(conf)
                .parse(json.asNode().getLiteralLexicalForm())
                .read(jsonquery.getString());
        List<NodeValue> nodeValues = new ArrayList<>(values.size());
        Gson gson = new Gson();
        for (Object value : values) {
            RDFDatatype dt = TypeMapper.getInstance().getSafeTypeByName(datatypeUri);
            String jsonstring = gson.toJson(value);
            Node node = NodeFactory.createLiteral(jsonstring, dt);
            NodeValue nodeValue = new NodeValueNode(node);
            nodeValues.add(nodeValue);
        }
        return nodeValues;
    } catch (Exception ex) {
        LOG.debug("No evaluation for " + json + ", " + jsonquery, ex);
        throw new ExprEvalException("No evaluation for " + json + ", " + jsonquery, ex);
    }
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public List<NodeValue> exec(NodeValue csv) {
    if (csv.getDatatypeURI() != null
            && !csv.getDatatypeURI().equals(datatypeUri)
            && !csv.getDatatypeURI().equals("http://www.w3.org/2001/XMLSchema#string")) {
        LOG.warn("The URI of NodeValue1 MUST be <" + datatypeUri + ">"
                + "or <http://www.w3.org/2001/XMLSchema#string>."
        );
    }
    List<NodeValue> nodeValues = new ArrayList<>();

    DocumentBuilderFactory builderFactory
            = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = null;
    try {

        String sourceCSV = String.valueOf(csv.asNode().getLiteralLexicalForm());

        InputStream is = new ByteArrayInputStream(sourceCSV.getBytes("UTF-8"));
        BufferedReader br = new BufferedReader(new InputStreamReader(is, "UTF-8"));

        CsvMapReader mapReader = new CsvMapReader(br, CsvPreference.STANDARD_PREFERENCE);
        String headers_str[] = mapReader.getHeader(true);

        for (String header : headers_str) {
            Node node = NodeFactory.createLiteral(header);
            NodeValueNode nodeValue = new NodeValueNode(node);
            nodeValues.add(nodeValue);
        }
        return nodeValues;
    } catch (Exception ex) {
        LOG.debug("No evaluation for " + csv, ex);
        throw new ExprEvalException("No evaluation for " + csv, ex);
    }
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@Override
public List<NodeValue> exec(NodeValue html, NodeValue cssSelector) {
    if (html.getDatatypeURI() != null
            && !html.getDatatypeURI().equals(datatypeUri)
            && !html.getDatatypeURI().equals("http://www.w3.org/2001/XMLSchema#string")) {
        LOG.warn("The URI of NodeValue1 MUST be"
                + " <" + datatypeUri + "> or"
                + " <http://www.w3.org/2001/XMLSchema#string>. Got <"
                + html.getDatatypeURI() + ">. Returning null.");
    }
    RDFDatatype dt = TypeMapper.getInstance()
            .getSafeTypeByName(datatypeUri);
    try {

        String sourceHtml = String.valueOf(html.asNode().getLiteralLexicalForm());
        Document htmldoc = Jsoup.parse(sourceHtml);

        String selectPath = String.valueOf(cssSelector.asNode().getLiteralValue());
        Elements elements = htmldoc.select(selectPath);

        LOG.debug("===> Number of iterations for " + cssSelector + " " + elements.size());

        List<NodeValue> nodeValues = new ArrayList<>(elements.size());

        NodeValue nodeValue;
        for (Element element : elements) {
            String htmlValue = element.toString();
            Node node = NodeFactory.createLiteral(htmlValue, dt);
            nodeValue = new NodeValueNode(node);

            nodeValues.add(nodeValue);
        }

        return nodeValues;
    } catch (Exception ex) {
        LOG.debug("No evaluation of " + html + ", " + cssSelector, ex);
        throw new ExprEvalException("No evaluation of " + html + ", " + cssSelector, ex);
    }
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
public JSLiteral literal(String value, Object langOrDatatype) {
	if(langOrDatatype instanceof JSNamedNode) {
		return new JSLiteral(NodeFactory.createLiteral(value, TypeMapper.getInstance().getTypeByName(((JSNamedNode)langOrDatatype).getValue())));
	}
	else if(langOrDatatype instanceof String) {
		return new JSLiteral(NodeFactory.createLiteral(value, (String)langOrDatatype));
	}
	else {
		throw new IllegalArgumentException("Invalid type of langOrDatatype argument");
	}
}
 

import org.apache.jena.graph.NodeFactory; //导入方法依赖的package包/类
@SuppressWarnings("rawtypes")
public static Node getNode(Object obj) {
	if(obj == null) {
		return null;
	}
	else if(obj instanceof JSTerm) {
		return ((JSTerm)obj).getNode();
	}
	else if(obj instanceof Map) {
		Map som = (Map) obj;
		String value = (String) som.get(VALUE);
		if(value == null) {
			throw new IllegalArgumentException("Missing value");
		}
		String termType = (String) som.get(TERM_TYPE);
		if(NAMED_NODE.equals(termType)) {
			return NodeFactory.createURI(value);
		}
		else if(BLANK_NODE.equals(termType)) {
			return NodeFactory.createBlankNode(value);
		}
		else if(LITERAL.equals(termType)) {
			String lang = (String) som.get(LANGUAGE);
			Map dt = (Map)som.get(DATATYPE);
			String dtURI = (String)dt.get(VALUE);
			RDFDatatype datatype = TypeMapper.getInstance().getSafeTypeByName(dtURI);
			return NodeFactory.createLiteral(value, lang, datatype);
		}
		else {
			throw new IllegalArgumentException("Unsupported term type " + termType);
		}
	}
	else {
		return null;
	}
}