Edit

     * @param restrictions

     *      This defines a filter for multiple properties represented by the map keys. Sine the keys are of the type

     *      {@link PropertyNameMatchMode} for each property a single MatchMode is defined. Multiple alternative values

     *      can be supplied per property, that is the values per property are combined with OR. The per property

     *      restrictions are combined with AND. </br>

     *      <b>NOTE:</b> For non string type properties you must use

    public List<T> list(Class<? extends T> type, Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

     * @param restrictions

     *      This defines a filter for multiple properties represented by the map keys. Sine the keys are of the type

     *      {@link PropertyNameMatchMode} for each property a single MatchMode is defined. Multiple alternative values

     *      can be supplied per property, that is the values per property are combined with OR. The per property

     *      restrictions are combined with AND. </br>

     *      <b>NOTE:</b> For non string type properties you must use

    public int count(Class<? extends T> type, Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions);

/**

* Copyright (C) 2017 EDIT

* European Distributed Institute of Taxonomy

* http://www.e-taxonomy.eu

*

* The contents of this file are subject to the Mozilla Public License Version 1.1

* See LICENSE.TXT at the top of this package for the full license terms.

*/

package eu.etaxonomy.cdm.persistence.dao.common;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

/**

 * @author a.kohlbecker

 * @since May 8, 2017

 *

 */

public class PropertyNameMatchMode {

    private String propertyName;

    private MatchMode matchMode;

    /**

     * @param propertyName

     * @param matchMode

     */

    public PropertyNameMatchMode(String propertyName, MatchMode matchMode) {

        this.propertyName = propertyName;

        this.matchMode = matchMode;

    }

    /**

     * @return the propertyName

     */

    public String getPropertyName() {

        return propertyName;

    }

    /**

     * @param propertyName the propertyName to set

     */

    public void setPropertyName(String propertyName) {

        this.propertyName = propertyName;

    }

    /**

     * @return the matchMode

     */

    public MatchMode getMatchMode() {

        return matchMode;

    }

    /**

     * @param matchMode the matchMode to set

     */

    public void setMatchMode(MatchMode matchMode) {

        this.matchMode = matchMode;

    }

}

import eu.etaxonomy.cdm.persistence.dao.common.PropertyNameMatchMode;

    public List<T> list(Class<? extends T> type, Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions,

        addRestrictions(restrictions, criteria);

     * @param restrictions

     * @param criteria

     */

    private void addRestrictions(Map<PropertyNameMatchMode, Collection<? extends Object>> restrictions, Criteria criteria) {

        List<Criterion> perProperty = new ArrayList<>(restrictions.size());

        for(PropertyNameMatchMode propMatchMode : restrictions.keySet()){

            Collection<? extends Object> values = restrictions.get(propMatchMode);

            if(values != null && !values.isEmpty()){

                Criterion[] predicates = new Criterion[values.size()];

                int i = 0;

                for(Object v : values){

                    predicates[i++] = createRestriction(propMatchMode.getPropertyName(), v, propMatchMode.getMatchMode());

                }

                perProperty.add(Restrictions.or(predicates));

            }

        }

        if(!perProperty.isEmpty()){

            criteria.add(Restrictions.and(perProperty.toArray(new Criterion[perProperty.size()])));

        }

    }

    /**

     * @return

    private Criterion createRestriction(String propertyName, Object value, MatchMode matchMode) {

        return restriction;

    public int count(Class<? extends T> type, Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions) {

        addRestrictions(restrictions, criteria);

import java.util.Collection;

import java.util.HashMap;

import java.util.Map;

import eu.etaxonomy.cdm.persistence.dao.common.PropertyNameMatchMode;

        Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions = new HashMap<>();

        List<AgentBase> result = agentDao.list(null, restrictions, (Integer)null, (Integer)null, null, null);

        List<AgentBase>  personResults = agentDao.list(Person.class, restrictions, (Integer)null, (Integer)null, null, null);

        Collection<String> values = new ArrayList<>();

        PropertyNameMatchMode firstNameExact = new PropertyNameMatchMode("firstname", MatchMode.EXACT);

        restrictions.put(firstNameExact,  values);

        personResults = agentDao.list(Person.class, restrictions, (Integer)null, (Integer)null, null, null);

        Assert.assertEquals("list() empty value lists should be ignored", 5, personResults.size());

        values.add("Ben");

        restrictions.put(firstNameExact, values);

        personResults = agentDao.list(Person.class, restrictions, (Integer)null, (Integer)null, null, null);

        Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions = new HashMap<>();

        Assert.assertEquals("count() should return 9 AgentBase entities", 9 , agentDao.count(null, restrictions));

        Assert.assertEquals("count() should return 5 Persons entities", 5, agentDao.count(Person.class, restrictions));

        Collection<String> values = new ArrayList<>();

        PropertyNameMatchMode firstNameExact = new PropertyNameMatchMode("firstname", MatchMode.EXACT);

        restrictions.put(firstNameExact,  values);

        Assert.assertEquals("count() empty value lists should be ignored", 5, agentDao.count(Person.class, restrictions));

        values.add("Ben");

        restrictions.put(firstNameExact, values);

        Assert.assertEquals("count() should return 1 Persons entity having the firstname 'Ben'", 1 , agentDao.count(Person.class, restrictions));

     *            Limits the result set to Registrations having the given submitter. This filter is ignored if set to <code>null</code>.

import java.util.Arrays;

import java.util.HashMap;

import java.util.Map;

import eu.etaxonomy.cdm.persistence.dao.common.PropertyNameMatchMode;

import eu.etaxonomy.cdm.persistence.query.MatchMode;

        int [] limitStart = AbstractPagerImpl.limitStartforRange(numberOfResults, pageIndex, pageSize);

        if(limitStart != null) {

            results = dao.list(reference, includedStatus, limitStart[0], limitStart[1], propertyPaths);

        return new DefaultPagerImpl<>(pageIndex, numberOfResults, pageSize, results);

        Map<PropertyNameMatchMode,  Collection<? extends Object>> restrictions = new HashMap<>();

        if(submitter != null){

            restrictions.put(new PropertyNameMatchMode("submitter", MatchMode.EXACT), Arrays.asList(submitter));

        }

        if(includedStatus != null && !includedStatus.isEmpty()){

            restrictions.put(new PropertyNameMatchMode("status", MatchMode.EXACT), includedStatus);

        }

        long numberOfResults = dao.count(Registration.class, restrictions);

        int [] limitStart = AbstractPagerImpl.limitStartforRange(numberOfResults, pageIndex, pageSize);

        if(limitStart != null) {

            results = dao.list(Registration.class, restrictions, limitStart[0], limitStart[1], orderHints, propertyPaths);

        return new DefaultPagerImpl<>(pageIndex, numberOfResults, pageSize, results);

	 * <p>

	 * {@link PagerUtils#limitFor(Integer)} and {@link PagerUtils#startFor(Integer, Integer)}.<br/>

     * <b>NOTE:</b> It is highly recommended to use the {@link #limitStartforRange(Long, Integer, Integer)} method instead which already

     * includes the calculation of <code>limit</code> and <code>start</code>.

	 *

	 * @deprecated use {@link #limitStartforRange(Long, Integer, Integer)} instead if appropriate.

	@Deprecated

	/**

     * Test if the the <code>numberOfResults</code> in the range of the page specified by <code>pageIndex</code> and <code>pageSize</code>.

     * And returns the according <code>limit</code> and <code>start</code> values as an array in case the test is successful. If there is no

     * result in the specified range the return value will be <code>null</code>.

     * <p>

     * When using this method in a service layer class you will also need to provide the according <code>limit</code> and <code>start</code>

     * parameters for dao list methods. The PagerUtil class provides the according methods for the required calculation:

     * {@link PagerUtils#limitFor(Integer)} and {@link PagerUtils#startFor(Integer, Integer)}

     *

     * @param numberOfResults

     * @param pageIndex

     * @param pageSize

     * @return An <code>int</code> array containing limit and start: <code>new int[]{limit, start}</code> or null if there is no result in the range of

     *  <code>pageIndex</code> and <code>pageSize</code>.

     */

    public static int[] limitStartforRange(Long numberOfResults, Integer pageIndex, Integer pageSize) {

        if(hasResultsInRange(numberOfResults, pageIndex, pageSize)){

            return  new int[]{PagerUtils.limitFor(pageSize), PagerUtils.startFor(pageSize, pageIndex)};

        }

        return null;

    }