DaoFilter.java

package org.wikibrain.core.dao;

import org.wikibrain.core.lang.Language;
import org.wikibrain.core.lang.LanguageSet;
import org.wikibrain.core.model.LocalLink;
import org.wikibrain.core.model.LocalPage;
import org.wikibrain.core.model.NameSpace;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;

/**
 *
 * A helper class for specifying complex queries.  To use, instantiate a new instance,
 * than call the various set methods in a chain to set the filters. Not all filters
 * are applied to all objects. Possible filters are, with the objects that use them:
 * <p>
 * - Language collection     (LocalPage, RawPage, LocalLink, Redirect, LocalCategoryMember) <p>
 * - NameSpace collection    (LocalPage, RawPage, UniversalPage) <p>
 * - Redirect flag           (LocalPage, RawPage) <p>
 * - Disambiguation flag     (LocalPage, RawPage) <p>
 * - LocationType collection (LocalLink) <p>
 * - Source ID collection    (LocalLink, Redirect, UniversalLink) <p>
 * - Dest ID collection      (LocalLink, Redirect, UniversalLink) <p>
 * - Parseable flag          (LocalLink, Redirect) <p>
 * - Algorithm ID collection (UniversalPage, UniversalLink) <p>
 * - Limit                   (All get() methods, but no getCount() methods<p>
 *
 * Collections are specified as a collection of acceptable entries, while flags are
 * booleans set to true, false, or null. Flags and collections set to null will be
 * ignored when the search is executed.
 *
 * A call might look something like:
 * DaoFilter df = new DaoFilter()
 *          .setLanguages(languageSet)
 *          .setNameSpace(nameSpaces)
 *          .setRedirect(true)
 *          .setDisambig(false);
 *
 * @author Ari Weiland
 *
 */
public class DaoFilter {

    private Collection<Short> langIds;
    private Collection<Short> nsIds;
    private Boolean isRedirect;
    private Boolean isDisambig;
    private Boolean hasDest;
    private Collection<Short> locTypeIds;
    private Collection<Integer> sourceIds;
    private Collection<Integer> destIds;
    private Boolean isParseable;
    private Integer limit;


    public DaoFilter() {
        langIds = null;
        nsIds = null;
        isRedirect = null;
        isDisambig = null;
        sourceIds = null;
        destIds = null;
        locTypeIds = null;
        isParseable = null;
        hasDest = null;
    }

    public Collection<Short> getLangIds() {
        return langIds;
    }

    public Collection<Short> getNameSpaceIds() {
        return nsIds;
    }

    public Boolean isRedirect() {
        return isRedirect;
    }

    public Boolean isDisambig() {
        return isDisambig;
    }

    public Collection<Short> getLocTypes() {
        return locTypeIds;
    }

    public Collection<Integer> getSourceIds() {
        return sourceIds;
    }

    public Collection<Integer> getDestIds() {
        return destIds;
    }

    public Boolean isParseable() {
        return isParseable;
    }

    /**
     * Sets the language filter to the specified LanguageSet.
     * Used by LocalPage, RawPage, LocalLink, Redirect, and LocalCategoryMember.
     * @param languages
     * @return
     */
    public DaoFilter setLanguages(LanguageSet languages) {
        return setLanguages(languages.getLanguages());
    }

    /**
     * Sets the language filter to the specified collection of languages.
     * Used by LocalPage, RawPage, LocalLink, Redirect, and LocalCategoryMember.
     * @param languages
     * @return
     */
    public DaoFilter setLanguages(Collection<Language> languages) {
        Collection<Short> temp = new ArrayList<Short>();
        if (languages==null || languages.isEmpty()) {
            temp = null;
        }
        else {
            for (Language l : languages) {
                temp.add(l.getId());
            }
        }
        this.langIds = temp;
        return this;
    }

    /**
     * Sets the language filter to the specified language.
     * Used by LocalPage, RawPage, LocalLink, Redirect, and LocalCategoryMember.
     * @param language
     * @return
     */
    public DaoFilter setLanguages(Language language) {
        return setLanguages(Arrays.asList(language));
    }

    /**
     * Sets the namespace filter to the specified collection of namespace constants.
     * Used by LocalPage, RawPage, and UniversalPage.
     * @param nameSpaces
     * @return
     */
    public DaoFilter setNameSpaces(Collection<NameSpace> nameSpaces) {
        Collection<Short> temp = new ArrayList<Short>();
        if (nameSpaces == null || nameSpaces.isEmpty()) {
            temp = null;
        }
        else {
            for (NameSpace ns : nameSpaces) {
                temp.add(ns.getArbitraryId());
            }
        }
        this.nsIds = temp;
        return this;
    }

    /**
     * Sets the namespace filter to the specified namespace constant.
     * Used by LocalPage, RawPage, and UniversalPage.
     * @param nameSpaces
     * @return
     */
    public DaoFilter setNameSpaces(NameSpace nameSpaces) {
        return setNameSpaces(Arrays.asList(nameSpaces));
    }

    /**
     * Sets the redirect flag.
     * Used by LocalPage and RawPage.
     * @param redirect
     * @return
     */
    public DaoFilter setRedirect(Boolean redirect) {
        this.isRedirect = redirect;
        return this;
    }

    /**
     * Sets the disambiguation flag.
     * Used by LocalPage and RawPage.
     * @param disambig
     * @return
     */
    public DaoFilter setDisambig(Boolean disambig) {
        this.isDisambig = disambig;
        return this;
    }

    /**
     * Whether or not links, etc. are required to have destinations.
     * @param hasDest
     */
    public DaoFilter setHasDest(Boolean hasDest) {
        this.hasDest = hasDest;
        return this;
    }


    public Boolean getHasDest() {
        return hasDest;
    }

    /**
     * Sets the Location Type filter for a LocalLink to the specified array.
     * Used only by LocalLink.
     * @param locTypes
     * @return
     */
    public DaoFilter setLocTypeIds(LocalLink.LocationType[] locTypes) {
        return setLocTypeIds(Arrays.asList(locTypes));
    }

    /**
     * Sets the Location Type filter for a LocalLink to the specified collection.
     * Used only by LocalLink.
     * @param locTypes
     * @return
     */
    public DaoFilter setLocTypeIds(Collection<LocalLink.LocationType> locTypes) {
        Collection<Short> temp = new ArrayList<Short>();
        if (locTypes == null || locTypes.isEmpty()) {
            temp = null;
        }
        else {
            for (LocalLink.LocationType lt : locTypes) {
                temp.add((short)lt.ordinal());
            }
        }
        this.locTypeIds = temp;
        return this;
    }

    /**
     * Sets the SourceIds filter to the specified collection.
     * Used by LocalLink, UniversalLink, and Redirect.
     * @param sourceIds
     * @return
     */
    public DaoFilter setSourceIds(Collection<Integer> sourceIds) {
        this.sourceIds = sourceIds;
        return this;
    }

    /**
     * Sets the SourceIds filter to the specified source ID.
     * Used by LocalLink, UniversalLink, and Redirect.
     * @param sourceId
     * @return
     */
    public DaoFilter setSourceIds(int sourceId) {
        return setSourceIds(Arrays.asList(sourceId));
    }

    /**
     * Sets the DestinationIds filter to the specified collection.
     * Used by LocalLink, UniversalLink, and Redirect.
     * @param destIds
     * @return
     */
    public DaoFilter setDestIds(Collection<Integer> destIds) {
        this.destIds = destIds;
        return this;
    }

    /**
     * Sets the DestinationIds filter to the specified destination ID.
     * Used by LocalLink, UniversalLink, and Redirect.
     * @param destId
     * @return
     */
    public DaoFilter setDestIds(int destId) {
        return setDestIds(Arrays.asList(destId));
    }

    /**
     * Sets the Parseable flag.
     * Used by LocalLink and Redirect.
     * @param parseable
     * @return
     */
    public DaoFilter setParseable(Boolean parseable) {
        isParseable = parseable;
        return this;
    }

    /**
     * @param limit The maximum number of results returned by queries
     * @return
     */
    public DaoFilter setLimit(int limit) {
        this.limit = limit;
        return this;
    }

    /**
     * @return Limit, or null
     */
    public Integer getLimit() {
        return limit;
    }

    /**
     * @return Limit, or Integer.MAX_VALUE if it is null
     */
    public Integer getLimitOrInfinity() {
        return limit == null ? Integer.MAX_VALUE : limit;
    }

    /**
     * Returns true if and only if the page is valid within the
     * parameters of this DaoFilter.
     * @param page
     * @return
     */
    public boolean isValidLocalPage(LocalPage page) {
        return page != null
                && (langIds    == null || langIds.contains(page.getLanguage().getId()))
                && (nsIds      == null || nsIds.contains(page.getNameSpace().getArbitraryId()))
                && (isRedirect == null || isRedirect == page.isRedirect())
                && (isDisambig == null || isDisambig == page.isDisambig());
    }


    public static DaoFilter normalPageFilter(Language language) {
        return new DaoFilter()
                .setDisambig(false)
                .setRedirect(false)
                .setNameSpaces(NameSpace.ARTICLE)
                .setLanguages(language);
    }
}