| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (the |
| * "License"); you may not use this file except in compliance |
| * with the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package org.apache.jena.assembler.assemblers; |
| |
| import java.io.StringReader; |
| import java.util.*; |
| |
| import org.apache.jena.assembler.* ; |
| import org.apache.jena.assembler.exceptions.UnknownEncodingException ; |
| import org.apache.jena.graph.Node ; |
| import org.apache.jena.rdf.model.* ; |
| import org.apache.jena.util.* ; |
| import org.apache.jena.vocabulary.* ; |
| |
| public class ContentAssembler extends AssemblerBase implements Assembler |
| { |
| protected final FileManager defaultFileManager; |
| |
| public ContentAssembler() |
| { this( null ); } |
| |
| public ContentAssembler( FileManager fm ) |
| { this.defaultFileManager = fm; } |
| |
| @Override public Object open( Assembler a, Resource root, Mode irrelevant ) |
| { |
| checkType( root, JA.Content ); |
| return new Content( loadContent( new ArrayList<Content>(), a, root ) ); |
| } |
| |
| public final static Set<Property> contentProperties = new HashSetWith<Property>() |
| .with( JA.content ) |
| .with( JA.literalContent ) |
| .with( JA.externalContent ) |
| .with( JA.quotedContent ) |
| ; |
| |
| static class HashSetWith<T> extends HashSet<T> |
| { |
| public HashSetWith<T> with( T x ) |
| { |
| this.add( x ); |
| return this; |
| } |
| } |
| |
| public List<Content> loadContent( List<Content> contents, Assembler a, Resource root ) |
| { |
| FileManager fm = getFileManager( a, root ); |
| addLiteralContent( contents, root ); |
| addQuotedContent( contents, root ); |
| addExternalContents( contents, fm, root ); |
| addIndirectContent( contents, a, root ); |
| return contents; |
| } |
| |
| private static void addIndirectContent( List<Content> contents, Assembler a, Resource root ) |
| { |
| StmtIterator it = root.listProperties( JA.content ); |
| while (it.hasNext()) contents.add( (Content) a.open( getResource( it.nextStatement() ) ) ); |
| } |
| |
| protected void addExternalContents( List<Content> contents, FileManager fm, Resource root ) |
| { |
| StmtIterator it = root.listProperties( JA.externalContent ); |
| while (it.hasNext()) contents.add( objectAsContent( fm, it.nextStatement() ) ); |
| } |
| |
| private static void addQuotedContent( List<Content> contents, Resource root ) |
| { |
| StmtIterator it = root.listProperties( JA.quotedContent ); |
| while (it.hasNext()) |
| { |
| Resource q = getResource( it.nextStatement() ); |
| Model m = ResourceUtils.reachableClosure( q ); |
| contents.add( newModelContent( m ) ); |
| } |
| } |
| |
| protected static void addLiteralContent( List<Content> contents, Resource root ) |
| { |
| String encoding = getEncoding( root ); |
| StmtIterator it = root.listProperties( JA.literalContent ); |
| while (it.hasNext()) |
| { |
| String s = getString( it.nextStatement() ); |
| Model model = parseAs( root, encoding, s ); |
| contents.add( newModelContent( model ) ); |
| } |
| } |
| |
| private static Model parseAs( Resource root, String encoding, String lexicalForm ) |
| { |
| String enc = encoding == null ? guessFrom( lexicalForm ) : encoding; |
| if (enc.equals( "N3" )) return parseAsN3( lexicalForm ); |
| if (enc.equals( "RDF/XML" )) return parseAsXML( lexicalForm ); |
| throw new UnknownEncodingException( root, encoding ); |
| } |
| |
| private static Model parseAsXML( String lexicalForm ) |
| { |
| String pre = |
| "<?xml version='1.0'?>" |
| + "<rdf:RDF" |
| + " xmlns:rdf='http://www.w3.org/1999/02/22-rdf-syntax-ns#'" |
| + " xmlns:rdfs='http://www.w3.org/2000/01/rdf-schema#'" |
| + " xmlns:xsd='http://www.w3.org/2001/XMLSchema#'" |
| + " xmlns:owl='http://www.w3.org/2002/07/owl#'" |
| + " xmlns:dc='http://purl.org/dc/elements/1.1/'" |
| + ">" |
| ; |
| String post = "</rdf:RDF>"; |
| StringReader r = new StringReader( pre + lexicalForm + post ); |
| return ModelFactory.createDefaultModel().read( r, "", "RDF/XML" ); |
| } |
| |
| private static String guessFrom( String lexicalForm ) |
| { return "N3"; } |
| |
| private static String getEncoding( Resource root ) |
| { |
| Literal L = getUniqueLiteral( root, JA.contentEncoding ); |
| return L == null ? null : L.getLexicalForm(); |
| } |
| |
| protected static Content newModelContent( final Model m ) |
| { |
| return new Content() |
| { |
| @Override public Model fill( Model x ) { x.setNsPrefixes( m ); return x.add( m ); } |
| |
| @Override public boolean isEmpty() { return m.isEmpty(); } |
| }; |
| } |
| |
| protected Content objectAsContent( FileManager fm, Statement s ) |
| { |
| final Model m = fm.loadModelInternal( getModelName( s ) ); |
| return newModelContent( m ); |
| } |
| |
| private String getModelName( Statement s ) |
| { |
| Node o = s.getObject().asNode(); |
| return o.isLiteral() ? o.getLiteralLexicalForm(): o.getURI(); |
| } |
| |
| private FileManager getFileManager( Assembler a, Resource root ) |
| { |
| Resource fm = getUniqueResource( root, JA.fileManager ); |
| return |
| fm != null ? (FileManager) a.open( fm ) |
| : defaultFileManager == null ? FileManager.getInternal() |
| : defaultFileManager |
| ; |
| } |
| |
| static final String preamble = |
| "@prefix rdf: <" + RDF.getURI() + "> ." |
| + "\n@prefix rdfs: <" + RDFS.getURI() + "> ." |
| + "\n@prefix owl: <" + OWL.getURI() + "> ." |
| + "\n@prefix xsd: <http://www.w3.org/2001/XMLSchema#> ." |
| + "\n@prefix dc: <" + DC_11.getURI() + "> ." |
| ; |
| |
| protected static Model parseAsN3( String value ) |
| { |
| Model result = ModelFactory.createDefaultModel(); |
| StringReader r = new StringReader( preamble +"\n" + value ); |
| result.read( r, "", "N3" ); |
| return result; |
| } |
| |
| public Object getFileManager() |
| { return defaultFileManager; } |
| } |