org.aksw.sparqlify.database.ExprNormalForm Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jena-sparql-api-views Show documentation
There is a newer version: 3.17.0-1
Show newest version
package org.aksw.sparqlify.database;

import java.util.Collection;
import java.util.HashSet;
import java.util.Map.Entry;
import java.util.Set;

import org.aksw.jena_sparql_api.normal_form.Clause;
import org.apache.commons.collections.CollectionUtils;
import org.apache.jena.sparql.core.Var;
import org.apache.jena.sparql.expr.Expr;

import com.google.common.collect.HashMultimap;
import com.google.common.collect.Multimap;

/*
class ExprIndex {
    private Multimap singleVar = HashMultimap.create();
    private

    public void add(Expr expr) {
        Set vars = expr.getVarsMentioned();
        if(vars.size() == 1) {
            singleVar.put(vars.iterator().next(), expr);
        }
    }

}*/

public abstract class ExprNormalForm {

    protected Multimap varToClauses = HashMultimap.create();
    protected Multimap, Clause> varsToClauses = HashMultimap.create();
    protected Multimap exprToClauses = HashMultimap.create();

    //protected Multimap

    // expressions that are part of all clauses
    protected Set commonExprs = new HashSet();

    protected Set varsMentioned = new HashSet();

    public Set filterByVars(Set requiredVars) {

        Set result = new HashSet();


        for(Entry, Collection> entry : varsToClauses.asMap().entrySet()) {

            Set clauseVars = entry.getKey();

            if(!clauseVars.containsAll(requiredVars)) {
                continue;
            }

            result.addAll(entry.getValue());
        }

        /*
        Collection clauses = getClauses();
        for(Clause clause : clauses) {
            Set clauseVars = clause.getVarsMentioned();

            if(!clauseVars.containsAll(requiredVars)) {
                continue;
            }

            result.add(clause);
        }*/

        return result;
    }

    public ExprNormalForm(Collection clauses) {
        addAll(clauses);
    }

    private void addAll(Collection clauses) {
        for(Clause clause : clauses) {
            add(clause);
        }
    }

    private boolean add(Clause clause) {
        Set vars = clause.getVarsMentioned();
        if(varsToClauses.put(vars, clause)) {
            for(Var var : vars) {
                varToClauses.put(var, clause);
            }

            varsMentioned.addAll(vars);


            // Map the new exprs to the clauses they appear in
            // and update the common exprs map
            if(exprToClauses.isEmpty()) {
                commonExprs.addAll(clause.getExprs());
            } else {
                commonExprs.retainAll(clause.getExprs());
            }


            for(Expr expr : clause.getExprs()) {
                exprToClauses.put(expr, clause);
            }

            return true;
        }

        return false;
    }


    /**
     * Return all expressions having exactly the specified vars
     *
     * @param vars
     * @return
     */
    public Collection getExactly(Set vars) {
        return varsToClauses.get(vars);
    }


    /*
    public static  Set getAll(Map map, Collection keys) {
        Set result = new HashSet();

        float scanFactor = 0.75f;
        Collection values = map.values();
        if(keys.size() > scanFactor * values.size()) {
            for(V clause : values) {
                if(CollectionUtils.containsAny(clause.getVarsMentioned(), keys)) {
                    result.add(clause);
                }
            }
        } else {
            // TODO Maybe its always faster to go with this option
            for(Object key : keys) {
                result.addAll(map.get(key));
            }
        }

        return result;
    }*/

    public Set get(Collection vars) {
        Set result = new HashSet();

        float scanFactor = 0.75f;
        Collection values = varsToClauses.values();
        if(vars.size() > scanFactor * values.size()) {
            for(Clause clause : values) {
                if(CollectionUtils.containsAny(clause.getVarsMentioned(), vars)) {
                    result.add(clause);
                }
            }
        } else {
            // TODO Maybe its always faster to go with this option
            for(Var var : vars) {
                result.addAll(varToClauses.get(var));
            }
        }

        return result;
    }

    public Collection get(Var var) {
        return varToClauses.get(var);
    }

    public Collection getClauses() {
        return varsToClauses.values();
    }

    @Override
    public String toString() {
        return varsToClauses.values().toString();
    }

    public Set getCommonExprs() {
        return commonExprs;
    }

    /*
    public Set getCommonExprs(Var var) {

    }*/

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result
                + ((varsToClauses == null) ? 0 : varsToClauses.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        ExprNormalForm other = (ExprNormalForm) obj;
        if (varsToClauses == null) {
            if (other.varsToClauses != null)
                return false;
        } else if (!varsToClauses.equals(other.varsToClauses))
            return false;
        return true;
    }

    public int size() {
        return varsToClauses.size();
    }


    public Set getVarsMentioned() {
        return varsMentioned;
    }


    /*
    public Dnf eval(Map binding) {

    }*/
}