org.apache.jena.shared.impl.PrefixMappingImpl Java Examples

/**
 * Creates a new Query from a partial query (possibly lacking
 * PREFIX declarations), using the ARQ syntax specified by <code>getSyntax</code>.
 * @param model  the Model to operate on
 * @param partialQuery  the (partial) query string
 * @return the Query
 */
public Query createQuery(Model model, String partialQuery) {
	PrefixMapping pm = new PrefixMappingImpl();
    String defaultNamespace = JenaUtil.getNsPrefixURI(model, "");
    if(defaultNamespace != null) {
        pm.setNsPrefix("", defaultNamespace);
    }
    Map<String,String> extraPrefixes = ExtraPrefixes.getExtraPrefixes();
    for(String prefix : extraPrefixes.keySet()) {
    	String ns = extraPrefixes.get(prefix);
    	if(ns != null && pm.getNsPrefixURI(prefix) == null) {
    		pm.setNsPrefix(prefix, ns);
    	}
    }

    // Get all the prefixes from the model at once.
    Map<String, String> map = model.getNsPrefixMap();
    map.remove("");
    pm.setNsPrefixes(map);
    
	return doCreateQuery(partialQuery, pm);
}
 

/**
 * Gets a parsable SPARQL string based on a fragment and prefix declarations.
 * Depending on the setting of the flag useGraphPrefixes, this either uses the
 * prefixes from the Jena graph of the given executable, or strictly uses sh:prefixes.
 * @param str  the query fragment (e.g. starting with SELECT)
 * @param executable  the sh:SPARQLExecutable potentially holding the sh:prefixes
 * @return the parsable SPARQL string
 */
public static String withPrefixes(String str, Resource executable) {
	if(useGraphPrefixes) {
		return ARQFactory.get().createPrefixDeclarations(executable.getModel()) + str;
	}
	else {
		StringBuffer sb = new StringBuffer();
		PrefixMapping pm = new PrefixMappingImpl();
		Set<Resource> reached = new HashSet<Resource>();
		for(Resource ontology : JenaUtil.getResourceProperties(executable, SH.prefixes)) {
			String duplicate = collectPrefixes(ontology, pm, reached);
			if(duplicate != null) {
				throw new SHACLException("Duplicate prefix declaration for prefix " + duplicate);
			}
		}
		for(String prefix : pm.getNsPrefixMap().keySet()) {
			sb.append("PREFIX ");
			sb.append(prefix);
			sb.append(": <");
			sb.append(pm.getNsPrefixURI(prefix));
			sb.append(">\n");
		}
		sb.append(str);
		return sb.toString();
	}
}
 

@Override
public PrefixMapping getPrefixMapping() {
	if (pm == null) {
		// copy delegate's prefix mapping.
		pm = new PrefixMappingImpl().setNsPrefixes(base.getPrefixMapping());
	}
	return pm;
}
 

public BdbTypeNameStore(DataStorage dataStore, String dataStoreRdfPrefix) throws IOException {
  this.dataStoreRdfPrefix = dataStoreRdfPrefix;
  prefixMapping = new PrefixMappingImpl();
  final String storedValue = dataStore.getValue();
  if (storedValue == null) {
    data = new TypeNames();
    addStandardPrefixes();
  } else {
    data = objectMapper.readValue(storedValue, new TypeReference<TypeNames>() {});
  }
  prefixMapping.setNsPrefixes(data.prefixes);
  this.dataStore = dataStore;
}
 

private PrefixMapping ensureRDFPrefix(PrefixMapping prefixes) {
	// Some prefix already registered for the RDF namespace -- good enough
	if (prefixes.getNsURIPrefix(RDF.getURI()) != null) return prefixes;
	// rdf: is registered to something else -- give up
	if (prefixes.getNsPrefixURI("rdf") != null) return prefixes;
	// Register rdf:
	PrefixMapping newPrefixes = new PrefixMappingImpl();
	newPrefixes.setNsPrefixes(prefixes);
	newPrefixes.setNsPrefix("rdf", RDF.getURI());
	return newPrefixes;
}
 

private QueryExecution createQueryExecution(Query query, Model model) {
	QueryExecution result = QueryExecutionFactory.create(query, model);
	PrefixMappingImpl prefixes = new PrefixMappingImpl();
	prefixes.setNsPrefixes(tq.getPrologue().getPrefixMapping());
	prefixes.setNsPrefix("tarql", tarql.NS);
	result.getContext().set(ExpandPrefixFunction.PREFIX_MAPPING, prefixes);
	return result;
}
 

@Before
public void setUp() {
	prefixes = new PrefixMappingImpl();
	prefixes.setNsPrefix("tarql", tarql.NS);
	env = new FunctionEnvBase();
	env.getContext().set(ExpandPrefixFunction.PREFIX_MAPPING, prefixes);
}
 

@Test
public void withoutPrefixMapping() {
	final MyTextOutput o = new MyTextOutput( new PrefixMappingImpl() );
	assertEquals("<http://example.com/i> <http://example.com/i> <http://example.com/i> ", getResult(o));
}
 

static public PrefixMapping getPrefixMappingForTests() {
	return new PrefixMappingImpl().setNsPrefix("ex", "http://example.com/");
}
 

@Before
public void setUp() {
	PrefixMapping prefixes = new PrefixMappingImpl();
	prefixes.setNsPrefix("ex", EX + "#");
}