/** * Used to write Resources for a Subject. Literals will by-pass this method and use "Literal" * method. * * @param predicate PredicateNode * @param object ObjectNode * @param writer PrintWriter * @throws GraphException */ protected void writeStatement( Graph graph, SubjectNode subject, PredicateNode predicate, ObjectNode object, PrintWriter writer) throws GraphException { // Literals are written differently if (object instanceof Literal) { this.writeStatement(graph, subject, predicate, (Literal) object, writer); } else if (object instanceof BlankNode) { // write as: <predicateURI> *blank node as subject* </predicateURI> writer.println(" <" + this.getURI(predicate) + ">"); // write blank node as a "subject" this.writeSubject(graph, (BlankNode) object, writer); writer.println(" </" + this.getURI(predicate) + ">"); } else if (subject instanceof BlankNode) { // predicatNode representing RDF Type PredicateNode rdfTypeNode = null; try { rdfTypeNode = graph.getElementFactory().createResource(RDF.TYPE); } catch (GraphElementFactoryException factoryException) { throw new GraphException("Could not create RDF Type node.", factoryException); } // do not write the RDF Type element if (!rdfTypeNode.equals(predicate)) { // write as: <predicateURI rdf:resource="resourceURI"/> writer.println( " <" + this.getURI(predicate) + " " + RDF_PREFIX + ":resource=\"" + this.getNodeString(object) + "\"/>"); } } else { // write as: <predicateURI rdf:resource="resourceURI"/> writer.println( " <" + this.getURI(predicate) + " " + RDF_PREFIX + ":resource=\"" + this.getNodeString(object) + "\"/>"); } }
/** * Writes the opening RDF tag (with namespaces) to the print Writer. * * @param out PrintWriter * @throws IOException */ protected void writeRDFHeader(PrintWriter out) throws IOException { // validate if (out != null) { // print opening RDF tag (including namespaces) out.print("<rdf:RDF "); // print namespaces Set<String> keys = namespaces.keySet(); if (keys != null) { for (String currentKey : keys) { String currentValue = namespaces.get(currentKey); if ((currentKey != null) && (currentValue != null)) { // use entities: xmlns:ns="&ns;" out.print(NEWLINE + " xmlns:" + currentKey + "=\"&" + currentKey + ";\""); } } } // close the opening tag (add a space for readability) out.print(">" + NEWLINE + NEWLINE); } else { throw new IllegalArgumentException("Cannot write to null Writer."); } }
/** * Writes the XML Entities (used for namespaces) to the print Writer. * * @param out PrintWriter * @throws IOException */ protected void writeXMLEntities(PrintWriter out) throws IOException { // validate if (out != null) { // print opening DOCTYPE DECLARATION tag out.print(NEWLINE + "<!DOCTYPE rdf:RDF ["); // print namespaces Set<String> keys = namespaces.keySet(); if (keys != null) { for (String currentKey : keys) { String currentValue = namespaces.get(currentKey); if ((currentKey != null) && (currentValue != null)) { // write as: <!ENTITY ns 'http://example.org/abc#'> out.print(NEWLINE + " <!ENTITY " + currentKey + " '" + currentValue + "'>"); } } } // close the opening tag (add a space for readability) out.print("]>" + NEWLINE + NEWLINE); } else { throw new IllegalArgumentException("Cannot write to null Writer."); } }
/** * Writes the XML Declaration and the opening RDF tag to the print Writer. Encoding attribute is * specified as the encoding argument. * * @param out PrintWriter * @throws IOException */ protected void writeHeader(OutputStreamWriter out) throws IOException { // validate if (out != null) { // wrapper for output stream writer (enable autoflushing) PrintWriter writer = new PrintWriter(out, true); // get encoding from the Encoding map String encoding = EncodingMap.getJava2IANAMapping(out.getEncoding()); // only insert encoding if there is a value if (encoding != null) { // print opening tags <?xml version="1.0" encoding=*encoding*?> writer.println("<?xml version=\"1.0\" encoding=\"" + encoding + "\"?>"); } else { // print opening tags <?xml version="1.0"?> writer.println("<?xml version=\"1.0\"?>"); } // print the Entities this.writeXMLEntities(writer); // print the opening RDF tag (including namespaces) this.writeRDFHeader(writer); } else { throw new IllegalArgumentException("Cannot write to null Writer."); } }
/** * Writes the opening tag for the subject * * @param graph JRDFGraph * @param subject SubjectNode * @param writer PrintWriter * @throws GraphException */ protected void writeClosingTag(Graph graph, BlankNode subject, PrintWriter writer) throws GraphException { ObjectNode subjectType = this.getSubjectType(graph, subject); // only display as a subject if it can be found if (subjectType != null) { // closing tag writer.print(" </" + this.getURI(subjectType) + ">" + NEWLINE); } else { // closing tag writer.print(" </" + RDF_PREFIX + ":Description>" + NEWLINE); } }
/** * Writes the opening tag for the subject * * @param graph JRDFGraph * @param subject SubjectNode * @param writer PrintWriter * @throws GraphException */ protected void writeOpeningTag(Graph graph, SubjectNode subject, PrintWriter writer) throws GraphException { if (writer != null) { // write the subject type and rdf:about if (subject != null) { // open tag - BlankNodes are a special case if (subject instanceof BlankNode) { this.writeOpeningTag(graph, (BlankNode) subject, writer); } else { writer.print( " <" + RDF_PREFIX + ":Description " + RDF_PREFIX + ":about=\"" + this.getNodeString(subject) + "\">" + NEWLINE); } } else { throw new IllegalArgumentException( "Could not write opening tag for subject. Subject Node is null."); } } }
/** * Used to write Resources for a Subject. Resources will use "ObjectNode" method. * * @param predicate PredicateNode * @param object Literal * @param writer PrintWriter * @throws GraphException */ protected void writeStatement( Graph graph, SubjectNode subject, PredicateNode predicate, Literal object, PrintWriter writer) throws GraphException { // determine if the Literal has a datatype URI datatype = object.getDatatypeURI(); // Get the lexical form of the literal String literalObject = object.getLexicalForm(); // Create the StringBuffer to hold the resultant string StringBuffer buffer = new StringBuffer(); // Escape the XML string StringUtil.quoteAV(literalObject, buffer); if (datatype != null) { // write as: <predicateURI rdf:datatype="datatype">"Literal value" // </predicateURI> writer.println( " <" + this.getURI(predicate) + " " + RDF_PREFIX + ":datatype=\"" + datatype + "\">" + buffer.toString() + "</" + this.getURI(predicate) + ">"); } else { // write as: <predicateURI>"Literal value"</predicateURI> writer.println( " <" + this.getURI(predicate) + ">" + buffer.toString() + "</" + this.getURI(predicate) + ">"); } }
/** * Writes the closing RDF tag to the writer. * * @param out PrintWriter * @throws IOException */ protected void writeFooter(PrintWriter out) throws IOException { // validate if (out != null) { // print closing RDF tag out.println("</" + RDF_PREFIX + ":RDF>"); } else { throw new IllegalArgumentException("Cannot write to null Writer."); } }
/** * Writes the opening tag for the subject * * @param graph JRDFGraph * @param subject SubjectNode * @param writer PrintWriter * @throws GraphException */ protected void writeClosingTag(Graph graph, SubjectNode subject, PrintWriter writer) throws GraphException { // Blank Nodes are written differently if (subject instanceof BlankNode) { this.writeClosingTag(graph, (BlankNode) subject, writer); } else { // closing tag writer.print(" </" + RDF_PREFIX + ":Description>" + NEWLINE); } }
/** * Writes a Subject to the writer * * @param graph JRDFGraph * @param subject SubjectNode * @param writer PrintWriter * @throws GraphException */ protected void writeSubject(Graph graph, SubjectNode subject, PrintWriter writer) throws GraphException { // opening subject tag (includes literals) this.writeOpeningTag(graph, subject, writer); // subject contents this.writeSubjectBody(graph, subject, writer); // closing subject tag this.writeClosingTag(graph, subject, writer); // put a space between Subjects writer.println(""); }
/** * Writes the XML Declaration and the opening RDF tag to the print Writer. Encoding not specified. * * @param out PrintWriter * @throws IOException */ protected void writeHeader(PrintWriter out) throws IOException { // validate if (out != null) { // print opening tags out.println("<?xml version=\"1.0\"?>"); // print the opening RDF tag (including namespaces) this.writeRDFHeader(out); } else { throw new IllegalArgumentException("Cannot write to null Writer."); } }