ConstructForClass.java

/*
 * Copyright 2020 Martynas Jusevičius <martynas@atomgraph.com>.
 *
 * Licensed 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 com.atomgraph.client.writer.function;

import com.atomgraph.client.util.Constructor;
import com.atomgraph.client.vocabulary.AC;
import static com.atomgraph.client.writer.ModelXSLTWriter.checkURI;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import javax.xml.transform.stream.StreamSource;
import net.sf.saxon.s9api.ExtensionFunction;
import net.sf.saxon.s9api.ItemType;
import net.sf.saxon.s9api.OccurrenceIndicator;
import net.sf.saxon.s9api.Processor;
import net.sf.saxon.s9api.QName;
import net.sf.saxon.s9api.SaxonApiException;
import net.sf.saxon.s9api.SequenceType;
import net.sf.saxon.s9api.XdmValue;
import com.atomgraph.client.util.jena.PrefixGraphRepository;
import org.apache.jena.ontapi.OntModelFactory;
import org.apache.jena.ontapi.OntSpecification;
import org.apache.jena.ontapi.model.OntClass;
import org.apache.jena.ontapi.model.OntModel;
import org.apache.jena.rdf.model.Model;
import org.apache.jena.rdf.model.ModelFactory;
import org.apache.jena.riot.RDFFormat;
import org.apache.jena.riot.RDFWriter;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

/**
 * <code>ac:construct()</code> XSLT function that constructs instances for given classes from their constructors.
 * Plugs into the Saxon processor.
 * 
 * @author Martynas Jusevičius {@literal <martynas@atomgraph.com>}
 * @see <a href="http://www.saxonica.com/documentation/#!extensibility/integratedfunctions">Integrated extension functions</a>
 */
public class ConstructForClass implements ExtensionFunction
{

    private static final Logger log = LoggerFactory.getLogger(ConstructForClass.class);

    private final Processor processor;
    private final PrefixGraphRepository repository;

    public ConstructForClass(Processor processor, PrefixGraphRepository repository)
    {
        this.processor = processor;
        this.repository = repository;
    }
    
    @Override
    public QName getName()
    {
        return new QName(AC.NS, "construct");
    }

    @Override
    public SequenceType getResultType()
    {
        return SequenceType.makeSequenceType(ItemType.DOCUMENT_NODE, OccurrenceIndicator.ZERO_OR_MORE);
    }

    @Override
    public SequenceType[] getArgumentTypes()
    {
        return new SequenceType[]
        {
            SequenceType.makeSequenceType(ItemType.ANY_URI, OccurrenceIndicator.ONE),
            SequenceType.makeSequenceType(ItemType.ANY_URI, OccurrenceIndicator.ZERO_OR_MORE),
            SequenceType.makeSequenceType(ItemType.ANY_URI, OccurrenceIndicator.ONE),
        };
    }

    @Override
    public XdmValue call(XdmValue[] arguments) throws SaxonApiException
    {
        try
        {
            String ontology = arguments[0].itemAt(0).getStringValue();
            String base = arguments[2].itemAt(0).getStringValue();
            
            Model instances = ModelFactory.createDefaultModel();
            try
            {
                OntModel ontModel = OntModelFactory.createModel(getRepository().get(ontology), OntSpecification.OWL2_FULL_MEM, getRepository());

                arguments[1].stream().
                    <OntClass>map(forClass -> ontModel.getOntClass(checkURI(forClass.getStringValue()).toString())).
                    filter(forClass -> forClass != null).
                    forEach(forClass -> new Constructor().construct(forClass, instances, base));
            }
            catch (RuntimeException ex) // ontology or one of its imports could not be loaded — return empty result instead of failing the transform
            {
                if (log.isWarnEnabled()) log.warn("Could not construct instances for ontology '{}': {}", ontology, ex.toString());
            }

            return getProcessor().newDocumentBuilder().build(getSource(instances));
        }
        catch (IOException ex)
        {
            throw new SaxonApiException(ex);
        }
    }
    
    public StreamSource getSource(Model model) throws IOException
    {
        if (model == null) throw new IllegalArgumentException("Model cannot be null");

        try (ByteArrayOutputStream stream = new ByteArrayOutputStream())
        {
            RDFWriter.create().
                format(RDFFormat.RDFXML_PLAIN).
                source(model).
                output(stream);
            return new StreamSource(new ByteArrayInputStream(stream.toByteArray()));
        }
    }
    
    public Processor getProcessor()
    {
        return processor;
    }
    
    public PrefixGraphRepository getRepository()
    {
        return repository;
    }
    
}