Examples with SimpleGraph org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph used on opensource projects

Example 6 with SimpleGraph

use of org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph in project stanbol by apache.

the class TrackingDereferencerBase method copyLdPath.

/**
     * Executes the {@link #ldpathProgram} using the parsed URI as context and
     * writes the the results to the parsed ImmutableGraph
     * @param uri the context
     * @param rdfBackend the RdfBackend the LDPath program is executed on
     * @param ldpathProgram The {@link Program} parsed via the dereference context
     * @param langs the set of languages to dereference
     * @param graph the graph to store the results
     * @param writeLock the write lock for the graph
     * @throws DereferenceException on any {@link EntityhubException} while
     * executing the LDPath program
     */
private void copyLdPath(IRI uri, RDFBackend<Object> rdfBackend, Program<Object> ldpathProgram, Set<String> langs, Graph graph, Lock writeLock) throws DereferenceException {
    //A RdfReference needs to be used as context
    RdfReference context = valueFactory.createReference(uri);
    //create the representation that stores results in an intermediate
    //graph (we do not want partial results on an error
    Graph ldPathResults = new SimpleGraph();
    RdfRepresentation result = valueFactory.createRdfRepresentation(uri, ldPathResults);
    //execute the LDPath Program and write results to the RDF ImmutableGraph
    try {
        for (org.apache.marmotta.ldpath.model.fields.FieldMapping<?, Object> mapping : ldpathProgram.getFields()) {
            Collection<?> values;
            try {
                values = mapping.getValues(rdfBackend, context);
            } catch (RuntimeException e) {
                throw new DereferenceException(uri, e);
            }
            if (values != null && !values.isEmpty()) {
                String fieldName = mapping.getFieldName();
                if (langs == null || langs.isEmpty()) {
                    result.add(fieldName, values);
                } else {
                    //filter for languages
                    for (Object value : values) {
                        if ((!(value instanceof Text)) || langs.contains(((Text) value).getLanguage())) {
                            result.add(fieldName, value);
                        }
                    //else text with filtered language ... do not add
                    }
                }
            }
        }
    } catch (EntityhubException e) {
        throw new DereferenceException(uri, e);
    }
    if (log.isTraceEnabled()) {
        log.trace("dereferenced via LDPath {}", ModelUtils.getRepresentationInfo(result));
    }
    if (!ldPathResults.isEmpty()) {
        //copy the results
        writeLock.lock();
        try {
            graph.addAll(ldPathResults);
        } finally {
            writeLock.unlock();
        }
    }
}

Example 7 with SimpleGraph

use of org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph in project stanbol by apache.

the class AbstractOntologyCollectorImpl method exportToGraph.

/**
     * This method has no conversion calls, to it can be invoked by subclasses that wish to modify it
     * afterwards.
     * 
     * @param merge
     * @return
     */
protected Graph exportToGraph(boolean merge, org.semanticweb.owlapi.model.IRI prefix) {
    // if (merge) throw new UnsupportedOperationException(
    // "Merge not implemented yet for Clerezza triple collections.");
    long before = System.currentTimeMillis();
    // No need to store, give it a name, or anything.
    Graph root = new SimpleGraph();
    IRI iri = new IRI(prefix + _id);
    // Add the import declarations for directly managed ontologies.
    if (root != null) {
        // Set the ontology ID
        root.add(new TripleImpl(iri, RDF.type, OWL.Ontology));
        if (merge) {
            log.warn("Merging of Clerezza triple collections is only implemented one level down. Import statements will be preserved for further levels.");
            Iterator<Triple> it;
            Set<RDFTerm> importTargets = new HashSet<RDFTerm>();
            for (OWLOntologyID ontologyId : managedOntologies) {
                ImmutableGraph g = getOntology(ontologyId, ImmutableGraph.class, false);
                root.addAll(g);
                it = g.filter(null, OWL.imports, null);
                while (it.hasNext()) {
                    org.semanticweb.owlapi.model.IRI tgt;
                    RDFTerm r = it.next().getObject();
                    try {
                        if (r instanceof IRI)
                            tgt = org.semanticweb.owlapi.model.IRI.create(((IRI) r).getUnicodeString());
                        else if (r instanceof Literal)
                            tgt = org.semanticweb.owlapi.model.IRI.create(((Literal) r).getLexicalForm());
                        else
                            tgt = org.semanticweb.owlapi.model.IRI.create(r.toString());
                        tgt = URIUtils.sanitize(tgt);
                        importTargets.add(new IRI(tgt.toString()));
                    } catch (Exception ex) {
                        log.error("FAILED to obtain import target from resource {}", r);
                        continue;
                    }
                }
                it = g.filter(null, RDF.type, OWL.Ontology);
                while (it.hasNext()) {
                    BlankNodeOrIRI ontology = it.next().getSubject();
                    log.debug("Removing all triples related to {} from {}", ontology, iri);
                    Iterator<Triple> it2 = g.filter(ontology, null, null);
                    while (it2.hasNext()) root.remove(it2.next());
                }
                /*
                     * Reinstate import statements, though. If imported ontologies were not merged earlier, we
                     * are not doing it now anyway.
                     */
                for (RDFTerm target : importTargets) root.add(new TripleImpl(iri, OWL.imports, target));
            }
        } else {
            String base = prefix + getID();
            for (int i = 0; i < backwardPathLength; i++) base = URIUtils.upOne(URI.create(base)).toString();
            base += "/";
            // The key set of managedOntologies contains the ontology IRIs, not their storage keys.
            for (OWLOntologyID ontologyId : managedOntologies) {
                org.semanticweb.owlapi.model.IRI physIRI = // .create(base + ontologyId.getVersionIRI()));
                org.semanticweb.owlapi.model.IRI.create(base + OntologyUtils.encode(ontologyId));
                root.add(new TripleImpl(iri, OWL.imports, new IRI(physIRI.toString())));
            }
        }
        log.debug("Clerezza export of {} completed in {} ms.", getID(), System.currentTimeMillis() - before);
    }
    return root;
}

Example 8 with SimpleGraph

use of org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph in project stanbol by apache.

the class ScopeImpl method exportToGraph.

/**
     * Get a Clerezza {@link Graph} representation of the scope.
     * 
     * @param merge
     *            if true the core and custom spaces will be recursively merged with the scope graph,
     *            otherwise owl:imports statements will be added.
     * @return the RDF representation of the scope as a modifiable graph.
     */
protected Graph exportToGraph(boolean merge, org.semanticweb.owlapi.model.IRI universalPrefix) {
    // No need to store, give it a name, or anything.
    Graph root = new SimpleGraph();
    IRI iri = new IRI(universalPrefix + getID());
    if (root != null) {
        // Set the ontology ID
        root.add(new TripleImpl(iri, RDF.type, OWL.Ontology));
        if (merge) {
            ImmutableGraph custom, core;
            // Get the subjects of "bad" triples (those with subjects of type owl:Ontology).
            Iterator<Triple> it;
            Set<BlankNodeOrIRI> ontologies = new HashSet<BlankNodeOrIRI>();
            Set<RDFTerm> importTargets = new HashSet<RDFTerm>();
            custom = this.getCustomSpace().export(ImmutableGraph.class, merge);
            // root.addAll(space);
            it = custom.filter(null, RDF.type, OWL.Ontology);
            while (it.hasNext()) ontologies.add(it.next().getSubject());
            it = custom.filter(null, OWL.imports, null);
            while (it.hasNext()) importTargets.add(it.next().getObject());
            core = this.getCoreSpace().export(ImmutableGraph.class, merge);
            // root.addAll(space);
            it = core.filter(null, RDF.type, OWL.Ontology);
            while (it.hasNext()) ontologies.add(it.next().getSubject());
            it = core.filter(null, OWL.imports, null);
            while (it.hasNext()) importTargets.add(it.next().getObject());
            // Make sure the scope itself is not in the "bad" subjects.
            ontologies.remove(iri);
            for (BlankNodeOrIRI nl : ontologies) log.debug("{} -related triples will not be added to {}", nl, iri);
            // Merge the two spaces, skipping the "bad" triples.
            log.debug("Merging custom space of {}.", getID());
            for (Triple t : custom) if (!ontologies.contains(t.getSubject()))
                root.add(t);
            log.debug("Merging core space of {}.", getID());
            for (Triple t : core) if (!ontologies.contains(t.getSubject()))
                root.add(t);
            /*
                 * Reinstate import statements, though. If imported ontologies were not merged earlier, we are
                 * not doing it now anyway.
                 */
            for (RDFTerm target : importTargets) root.add(new TripleImpl(iri, OWL.imports, target));
        } else {
            IRI physIRI = new IRI(universalPrefix.toString() + this.getID() + "/" + SpaceType.CUSTOM.getIRISuffix());
            root.add(new TripleImpl(iri, OWL.imports, physIRI));
            physIRI = new IRI(universalPrefix.toString() + this.getID() + "/" + SpaceType.CORE.getIRISuffix());
            root.add(new TripleImpl(iri, OWL.imports, physIRI));
        }
    }
    return root;
}

Example 9 with SimpleGraph

use of org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph in project stanbol by apache.

the class MultiThreadedTestBase method createRdfDataIterator.

/**
     * Iterator implementation that parses an RDF graph from the parsed
     * {@link InputStream}. The RDF data are loaded in-memory. Because of this
     * only test data that fit in-memory can be used. <p>
     * Literal values (objects) of the {@link #PROPERTY_TEST_DATA_PROPERTY} are
     * used as data. If this property is not present {@link #DEFAULT_TEST_DATA_PROPERTY}
     * is used. If {@link #PROPERTY_TEST_DATA_PROPERTY} is set to '*' than all
     * Triples with Literal values are used.<p>
     * This supports all RDF-formats supported by the {@link JenaParserProvider} and
     * {@link RdfJsonParsingProvider}. The charset is expected to be UTF-8.
     * @param is the input stream providing the RDF test data.
     * @param mediaType the Media-Type of the stream. MUST BE supported by
     * the Apache Clerezza RDF parsers.
     */
private Iterator<String> createRdfDataIterator(InputStream is, String mediaType, final String propertyString) {
    final SimpleGraph graph = new SimpleGraph();
    try {
        rdfParser.parse(graph, is, mediaType);
    } catch (UnsupportedFormatException e) {
        Assert.fail("The MimeType '" + mediaType + "' of the parsed testData " + "is not supported. This utility supports plain text files as " + "as well as the RDF formats " + rdfParser.getSupportedFormats() + "If your test data uses one of those formats but it was not " + "correctly detected you can use the System property '" + PROPERTY_TEST_DATA_TYPE + "' to manually parse the Media-Type!");
    }
    IOUtils.closeQuietly(is);
    return new Iterator<String>() {

        Iterator<Triple> it = null;

        String next = null;

        private String getNext() {
            if (it == null) {
                IRI property;
                if ("*".equals(propertyString)) {
                    //wildcard
                    property = null;
                    log.info("Iterate over values of all Triples");
                } else {
                    property = new IRI(NamespaceMappingUtils.getConfiguredUri(nsPrefixService, propertyString));
                    log.info("Iterate over values of property {}", property);
                }
                it = graph.filter(null, property, null);
            }
            while (it.hasNext()) {
                RDFTerm value = it.next().getObject();
                if (value instanceof Literal) {
                    return ((Literal) value).getLexicalForm();
                }
            }
            //no more data
            return null;
        }

        @Override
        public boolean hasNext() {
            if (next == null) {
                next = getNext();
            }
            return next != null;
        }

        @Override
        public String next() {
            if (next == null) {
                next = getNext();
            }
            if (next == null) {
                throw new NoSuchElementException("No further testData available");
            } else {
                String elem = next;
                next = null;
                return elem;
            }
        }

        @Override
        public void remove() {
            throw new UnsupportedOperationException();
        }
    };
}

Example 10 with SimpleGraph

use of org.apache.clerezza.commons.rdf.impl.utils.simple.SimpleGraph in project stanbol by apache.

the class RefactorerImpl method graphRefactoring.

@SuppressWarnings("unchecked")
@Override
public Graph graphRefactoring(Graph inputGraph, Recipe recipe) throws RefactoringException {
    RuleAdapter ruleAdapter;
    try {
        ruleAdapter = ruleAdapterManager.getAdapter(recipe, ConstructQuery.class);
        List<ConstructQuery> constructQueries = (List<ConstructQuery>) ruleAdapter.adaptTo(recipe, ConstructQuery.class);
        for (ConstructQuery constructQuery : constructQueries) {
            System.out.println(constructQuery.toString());
        }
        Graph unionGraph = new SimpleGraph();
        for (ConstructQuery constructQuery : constructQueries) {
            unionGraph.addAll(sparqlConstruct(constructQuery, inputGraph));
        }
        return unionGraph;
    } catch (UnavailableRuleObjectException e) {
        throw new RefactoringException("The cause of the refactoring excpetion is: " + e.getMessage(), e);
    } catch (UnsupportedTypeForExportException e) {
        throw new RefactoringException("The cause of the refactoring excpetion is: " + e.getMessage(), e);
    } catch (RuleAtomCallExeption e) {
        throw new RefactoringException("The cause of the refactoring excpetion is: " + e.getMessage(), e);
    }
}