public static Resource getSubject(Model r, Resource predicate, RDFNode object)
throws ModelException {
Model m = r.find(null, predicate, object);
if (m == null || m.size() == 0) return null;
// if(m.size() > 1)
// throw new RuntimeException("Model contains more than one triple");
return ((Statement) m.elements().nextElement()).subject();
}
public static RDFNode getObject(Model r, Resource subject, Resource predicate)
throws ModelException {
Model m = r.find(subject, predicate, null);
if (m == null || m.size() == 0) return null;
// if(m.size() > 1)
// throw new RuntimeException("Model contains more than one triple");
// FIXME: we do not check whether it is a resource or literal
return ((Statement) m.elements().nextElement()).object();
}
/** Collects the triples of a model into an array. */
public static Statement[] getStatementArray(Model m) throws ModelException {
Statement[] v = new Statement[m.size()];
int i = 0;
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement t = (Statement) en.nextElement();
v[i++] = t;
}
return v;
}
// FIXME: use digest instead of size
static void getReachable(Resource r, Model m, Model result) throws ModelException {
int oldSize = result.size();
Model directlyReachable = m.find(r, null, null);
SetOperations.unite(result, directlyReachable);
if (result.size() == oldSize) return;
for (Enumeration en = directlyReachable.elements(); en.hasMoreElements(); ) {
Statement t = (Statement) en.nextElement();
if (t.object() instanceof Resource) getReachable((Resource) t.object(), m, result);
}
}
/** returns true if old triples from r were removed */
public static boolean setUniqueObject(
Model r, Resource subject, Resource predicate, RDFNode object) throws ModelException {
Model old = r.find(subject, predicate, null);
SetOperations.subtract(r, old);
Statement stmt = get1(old);
if (subject == null && stmt != null) subject = stmt.subject();
if (predicate == null && stmt != null) predicate = stmt.predicate();
r.add(r.getNodeFactory().createStatement(subject, predicate, object));
return !old.isEmpty();
}
/**
* @return a new model in which all occurrences of the old namespace are replaced by the new one.
* All replaced resources are summarized in the map if not null. If resourcesToIgnore != null,
* ignore resources listed there.
*/
public static Model replaceNamespace(Model m, String o, String n, Map o2n, Set resourcesToIgnore)
throws ModelException {
Model res = m.create();
NodeFactory f = m.getNodeFactory();
Enumeration en = m.elements();
while (en.hasMoreElements()) {
Statement st = (Statement) en.nextElement();
res.add(replaceNamespace(st, o, n, f, o2n, resourcesToIgnore));
}
return res;
}
public static List getObjects(Model m, Resource subject, Resource predicate)
throws ModelException {
List result = new ArrayList();
if (m == null || m.size() == 0) return result;
for (Enumeration en = m.find(subject, predicate, null).elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
result.add(st.object());
}
return result;
}
/** tries to determine the file name from getSourceURI */
public static void saveModel(Model m, RDFSerializer s)
throws FileNotFoundException, IOException, ModelException, SerializationException {
// URI to filename
URL url = null;
try {
url = new URL(m.getSourceURI());
} catch (Exception any) {
throw new ModelException("RDFUtil: cannot determine model file name: " + m.getSourceURI());
}
if ("file".equals(url.getProtocol()))
saveModel(m, url.getFile().replace('/', File.separatorChar), s);
else
throw new ModelException("RDFUtil: cannot save to non-file model URI: " + m.getSourceURI());
}
/** Removes all triples which have something to do with the given namespace */
public static Model removeNamespace(String ns, Model m) throws ModelException {
Model res = m.duplicate();
for (Enumeration en = m.duplicate().elements(); en.hasMoreElements(); ) {
Statement t = (Statement) en.nextElement();
if (t.subject().toString().startsWith(ns)
|| t.predicate().toString().startsWith(ns)
|| t.object().toString().startsWith(ns)) {
// System.err.println("REMOVING TRIPLE: " + t);
res.remove(t);
}
}
return res;
}
public static Set toSet(Model m) throws ModelException {
Set s = new HashSet();
Enumeration en = m.elements();
while (en.hasMoreElements()) s.add(en.nextElement());
return s;
}
public static void collectLiterals(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
if (st.object() instanceof Literal) target.add(st.object());
}
}
/**
* @return a new model in which all occurrences of the old resources are replaced by the new ones.
* Returns number replacements done.
*/
public static int replaceResources(Model src, Model dest, Map o2n) throws ModelException {
NodeFactory f = src.getNodeFactory();
Enumeration en = src.elements();
int replaced = 0;
while (en.hasMoreElements()) {
Statement st = (Statement) en.nextElement();
Statement st_n = replaceResources(st, f, o2n);
dest.add(st_n);
if (st_n != st) // yes, pointer comparison
replaced++;
}
return replaced;
}
public static void collectPredicates(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
target.add(st.predicate());
}
}
public static void collectNamespaces(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
collectNamespaces(st, target);
}
}
/** Prints the triples of a model to the given PrintStream. */
public static void printStatements(Model m, PrintStream ps) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement t = (Statement) en.nextElement();
ps.println(t); // "triple(\""+t.subject()+"\",\""+t.predicate()+"\",\""+t.object()+"\").");
}
}
/** Fills <tt>m</tt> with statements from <tt>s</tt> and returns it. */
public static Model toModel(Set s, Model m) throws ModelException {
Iterator it = s.iterator();
while (it.hasNext()) {
Object o = it.next();
if (o instanceof Statement) m.add((Statement) o);
}
return m;
}
/** Collects the triples of a model in a vector. */
public static Vector getStatementVector(Model m) throws ModelException {
Vector v = new Vector();
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement t = (Statement) en.nextElement();
v.addElement(t);
}
return v;
}
public static Hashtable getNodes(Model m) throws ModelException {
Hashtable t = new Hashtable();
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement s = (Statement) en.nextElement();
t.put(s.subject(), s.subject());
t.put(s.object(), s.object());
}
return t;
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
String path = request.getPathInfo();
boolean htmlOutput = true;
String language = null;
String contentType = "text/html; charset='utf-8'";
if (path != null) {
if (path.endsWith(".rdf")) {
contentType = "application/rdf+xml; charset='utf-8'";
htmlOutput = false;
language = "RDF/XML";
} else if (path.endsWith(".xml")) {
contentType = "application/xml; charset='utf-8'";
htmlOutput = false;
language = "RDF/XML";
} else if (path.endsWith(".n3")) {
contentType = "text/n3; charset='utf-8'";
htmlOutput = false;
language = "N3";
}
}
response.setContentType(contentType);
response.setStatus(HttpServletResponse.SC_OK);
Writer writer = response.getWriter();
synchronized (board) {
if (htmlOutput) {
writer.write(
"<!DOCTYPE html>\n"
+ "<html lang='en'>"
+ "<head><meta charset='utf-8'/><title>MATe model</title></head>"
+ "<body><ul>");
StmtIterator it = model.listStatements();
/* TODO: well, this could be prettier */
while (it.hasNext()) writer.write("<li>" + it.nextStatement() + "</li>");
writer.write("<ul></body></html>");
} else model.write(writer, language);
}
}
public static void collectResources(Model m, Collection target) throws ModelException {
for (Enumeration en = m.elements(); en.hasMoreElements(); ) {
Statement st = (Statement) en.nextElement();
if (!(st.object() instanceof Literal) && !(st.object() instanceof Statement))
target.add(st.object());
target.add(st.subject());
target.add(st.predicate());
}
}
/**
* @return a new model in which all occurrences of the old resources are replaced by the new ones.
* Returns number replacements done.
*/
public static int replaceResources(Model m, Map o2n) throws ModelException {
NodeFactory f = m.getNodeFactory();
Enumeration en = m.elements();
Model toRemove = m.create();
Model toAdd = m.create();
while (en.hasMoreElements()) {
Statement st = (Statement) en.nextElement();
Statement st_n = replaceResources(st, f, o2n);
if (st_n != st) { // yes, pointer comparison
toAdd.add(st_n);
toRemove.add(st);
}
}
SetOperations.subtract(m, toRemove);
SetOperations.unite(m, toAdd);
return toAdd.size();
}
public static void parse(String fileNameOrURL, RDFParser parser, Model model)
throws IOException, SAXException, MalformedURLException, ModelException {
URL url = new URL(normalizeURI(fileNameOrURL));
// maybe this model is loaded as schema...
// Model model = factory.registry().get(url.toString());
// if(model != null)
// return model;
// Prepare input source
model.setSourceURI(url.toString());
InputStream in = url.openStream();
InputSource source = new InputSource(in);
source.setSystemId(url.toString());
parser.parse(source, new ModelConsumer(model));
in.close();
}
/** Creates a new unique unnamed resource. */
public static Resource noname(Model m) throws ModelException {
return m.getNodeFactory().createUniqueResource();
}
public static void add(Model m, Resource subject, Resource predicate, RDFNode object)
throws ModelException {
m.add(m.getNodeFactory().createStatement(subject, predicate, object));
}
public static boolean isInstanceOf(Model r, Resource i, Resource cls) throws ModelException {
return !r.find(i, RDF.type, cls).isEmpty();
}
/**
* returns a subgraph of "m" containing "r" and all nodes reachable from "r" via directed edges.
* These edges are also included in the resulting model.
*/
public static Model getReachable(Resource r, Model m) throws ModelException {
Model result = m.create();
getReachable(r, m, result);
return result;
}
/** Returns the first triple of the model */
public static Statement get1(Model m) throws ModelException {
if (m == null || m.isEmpty()) return null;
// if(m.size() > 1)
// throw new RuntimeException("Model contains more than one triple");
return (Statement) m.elements().nextElement();
}