org.coode.oppl.function.inline.InlineSet Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of oppl2-oppl2 Show documentation
There is a newer version: 5.0.0
package org.coode.oppl.function.inline;

import static org.coode.oppl.utils.ArgCheck.checkNotNull;

import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Set;

import org.coode.oppl.ConstraintSystem;
import org.coode.oppl.ManchesterVariableSyntax;
import org.coode.oppl.function.*;
import org.coode.oppl.variabletypes.*;
import org.semanticweb.owlapi.model.IRI;
import org.semanticweb.owlapi.model.OWLDataFactory;
import org.semanticweb.owlapi.model.OWLObject;
import org.semanticweb.owlapi.util.ShortFormProvider;

/** @author Luigi Iannone
 * @param 
 *            type */
public final class InlineSet implements Set, OPPLFunction> {
    private final Set delegate = new HashSet();
    private final Set>> aggregandums = new HashSet>>();

    /** @param variableType
     *            variableType
     * @param aggregandums
     *            aggregandums
     * @param dataFactory
     *            dataFactory
     * @param constraintSystem
     *            constraintSystem */
    public InlineSet(VariableType variableType,
            Collection>> aggregandums,
            final OWLDataFactory dataFactory, final ConstraintSystem constraintSystem) {
        this.aggregandums.addAll(checkNotNull(aggregandums, "aggregandums"));
        for (Aggregandum> a : this.aggregandums) {
            final String render = a.render(constraintSystem);
            final IRI rendered = IRI.create(String.format("%s#%s", ManchesterVariableSyntax.NAMESPACE, render));
        this.delegate.add(variableType.accept(new VariableTypeVisitorEx() {
            @Override
            @SuppressWarnings("unchecked")
                public O visitCLASSVariableType(CLASSVariableType v) {
                    return (O) dataFactory.getOWLClass(rendered);
            }

            @Override
            @SuppressWarnings("unchecked")
                public O visitOBJECTPROPERTYVariableType(OBJECTPROPERTYVariableType v) {
                    return (O) dataFactory.getOWLObjectProperty(rendered);
            }

            @Override
            @SuppressWarnings("unchecked")
                public O visitDATAPROPERTYVariableType(DATAPROPERTYVariableType v) {
                    return (O) dataFactory.getOWLDataProperty(rendered);
            }

            @Override
            @SuppressWarnings("unchecked")
                public O visitINDIVIDUALVariableType(INDIVIDUALVariableType v) {
                    return (O) dataFactory.getOWLNamedIndividual(rendered);
            }

            @Override
            @SuppressWarnings("unchecked")
                public O visitCONSTANTVariableType(CONSTANTVariableType v) {
                    return (O) dataFactory.getOWLLiteral(render);
            }

            @Override
            @SuppressWarnings("unchecked")
                public O visitANNOTATIONPROPERTYVariableType(ANNOTATIONPROPERTYVariableType v) {
                    return (O) dataFactory.getOWLAnnotationProperty(rendered);
            }
        }));
    }
    }

    /** @return aggregandums */
    public Set>> getAggregandums() {
        return new HashSet>>(this.aggregandums);
    }

    @Override
    public void accept(OPPLFunctionVisitor visitor) {
        visitor.visitInlineSet(this);
    }

    @Override
    public  P accept(OPPLFunctionVisitorEx
 visitor) {
        return visitor.visitInlineSet(this);
    }

    @Override
    public Set compute(ValueComputationParameters params) {
        Set toReturn = new HashSet();
        for (Aggregandum> aggregandum : this.aggregandums) {
            Set>> opplFunctions = aggregandum
                    .getOPPLFunctions();
            for (OPPLFunction> opplFunction : opplFunctions) {
                Collection value = opplFunction.compute(params);
                toReturn.addAll(value);
            }
        }
        return toReturn;
    }

    @Override
    public String render(ConstraintSystem constraintSystem) {
        StringBuilder out = new StringBuilder("set(");
        Iterator>> aggregandumIterator = this.aggregandums
                .iterator();
        while (aggregandumIterator.hasNext()) {
            Aggregandum> aggregandum = aggregandumIterator.next();
            String comma = aggregandumIterator.hasNext() ? ", " : "";
            out.append(aggregandum.render(constraintSystem)).append(comma);
        }
        out.append(")");
        return out.toString();
    }

    @Override
    public String render(ShortFormProvider shortFormProvider) {
        StringBuilder out = new StringBuilder("set(");
        Iterator>> aggregandumIterator = this.aggregandums
                .iterator();
        while (aggregandumIterator.hasNext()) {
            Aggregandum> aggregandum = aggregandumIterator.next();
            String comma = aggregandumIterator.hasNext() ? ", " : "";
            out.append(aggregandum.render(shortFormProvider)).append(comma);
        }
        out.append(")");
        return out.toString();
    }

    /** @param dataFactory
     *            dataFactory
     * @param constraintSystem
     *            constraintSystem
     * @param variableType
     *            variableType
     * @param components
     *            components
     * @param objects
     *            objects
     * @param 

     *            set type
     * @return inline set */
    public static 
 InlineSet
 buildInlineSet(
            OWLDataFactory dataFactory, ConstraintSystem constraintSystem,
            VariableType
 variableType, Collection> components,
            P... objects) {
        Set>> set = new HashSet>>();
        for (InlineSet
 inlineSet : components) {
            Set>> aggregandums = inlineSet
                    .getAggregandums();
            set.addAll(aggregandums);
        }
        for (P p : objects) {
            set.add(Adapter.buildAggregandumOfCollection(p));
        }
        return new InlineSet(variableType, set, dataFactory, constraintSystem);
    }

    // Delegate methods
    @Override
    public boolean add(O o) {
        return this.delegate.add(o);
    }

    @Override
    public boolean addAll(Collection c) {
        return this.delegate.addAll(c);
    }

    @Override
    public void clear() {
        this.delegate.clear();
    }

    @Override
    public boolean contains(Object o) {
        return this.delegate.contains(o);
    }

    @Override
    public boolean containsAll(Collection c) {
        return this.delegate.containsAll(c);
    }

    @Override
    public boolean equals(Object o) {
        return this.delegate.equals(o);
    }

    @Override
    public int hashCode() {
        return this.delegate.hashCode();
    }

    @Override
    public boolean isEmpty() {
        return this.delegate.isEmpty();
    }

    @Override
    public Iterator iterator() {
        return this.delegate.iterator();
    }

    @Override
    public boolean remove(Object o) {
        return this.delegate.remove(o);
    }

    @Override
    public boolean removeAll(Collection c) {
        return this.delegate.removeAll(c);
    }

    @Override
    public boolean retainAll(Collection c) {
        return this.delegate.retainAll(c);
    }

    @Override
    public int size() {
        return this.delegate.size();
    }

    @Override
    public Object[] toArray() {
        return this.delegate.toArray();
    }

    @Override
    public  T[] toArray(T[] a) {
        return this.delegate.toArray(a);
    }
}