// license-header java merge-point
   //
   // Attention: Generated code! Do not modify by hand!
   // Generated by: hibernate/SpringHibernateDaoBase.vsl in <project>/mda/src/main/cartridge/custom/...
   //
   package fr.ifremer.quadrige2.core.dao.administration.user;
   
   /*-
    * #%L
   * Quadrige2 Core :: Server API
   * %%
   * Copyright (C) 2017 Ifremer
   * %%
   * This program is free software: you can redistribute it and/or modify
   * it under the terms of the GNU Affero General Public License as published by
   * the Free Software Foundation, either version 3 of the License, or
   * (at your option) any later version.
   * 
   * This program is distributed in the hope that it will be useful,
   * but WITHOUT ANY WARRANTY; without even the implied warranty of
   * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   * GNU General Public License for more details.
   * 
   * You should have received a copy of the GNU Affero General Public License
   * along with this program.  If not, see <http://www.gnu.org/licenses/>.
   * #L%
   */
  
  import fr.ifremer.quadrige2.core.dao.PrincipalStore;
  import fr.ifremer.quadrige2.core.dao.PropertySearch;
  import fr.ifremer.quadrige2.core.dao.Search;
  import fr.ifremer.quadrige2.core.dao.referential.Status;
  import fr.ifremer.quadrige2.core.dao.technical.hibernate.HibernateDaoSupport;
  import fr.ifremer.quadrige2.core.vo.administration.user.LightQuserVO;
  import fr.ifremer.quadrige2.core.vo.administration.user.QuserVO;
  import java.security.Principal;
  import java.sql.Timestamp;
  import java.util.ArrayList;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Iterator;
  import java.util.LinkedHashSet;
  import java.util.List;
  import java.util.Set;
  import javax.annotation.Resource;
  import org.andromda.spring.PaginationResult;
  import org.apache.commons.collections.CollectionUtils;
  import org.apache.commons.collections.Transformer;
  import org.hibernate.Criteria;
  import org.hibernate.HibernateException;
  import org.hibernate.Query;
  import org.hibernate.ScrollableResults;
  
  /**
   * <p>
   * Base Spring DAO Class: is able to create, update, remove, load, and find
   * objects of type <code>Quser</code>.
   * </p>
   *
   * @see Quser
   */
  public abstract class QuserDaoBase
      extends HibernateDaoSupport    
      implements QuserDao
  {
      /**
       * {@inheritDoc}
       */
      @Override
      public Object get(final int transform, final Integer quserId)
      {
          if (quserId == null)
          {
              throw new IllegalArgumentException(
                  "Quser.get - 'quserId' can not be null");
          }
          final Quser entity = get(QuserImpl.class, quserId);
          return transformEntity(transform, entity);
      }
      /**
       * {@inheritDoc}
       */
      @Override
      public Quser get(Integer quserId)
      {
          return (Quser)this.get(TRANSFORM_NONE, quserId);
      }
  
      /**
       * {@inheritDoc}
       */
      @Override
      public Object load(final int transform, final Integer quserId)
      {
          if (quserId == null)
          {
              throw new IllegalArgumentException(
                  "Quser.load - 'quserId' can not be null");
          }
         final Quser entity = get(QuserImpl.class, quserId);
         return transformEntity(transform, entity);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Quser load(Integer quserId)
     {
         return (Quser)this.load(TRANSFORM_NONE, quserId);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({"unchecked"})
     public Collection<Quser> loadAll()
     {
         return (Collection<Quser>) this.loadAll(QuserDao.TRANSFORM_NONE);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Collection<?> loadAll(final int transform)
     {
         return this.loadAll(transform, -1, -1);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Collection<?> loadAll(final int pageNumber, final int pageSize)
     {
         return this.loadAll(QuserDao.TRANSFORM_NONE, pageNumber, pageSize);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Collection<?> loadAll(final int transform, final int pageNumber, final int pageSize)
     {
         try
         {
             final Criteria criteria = this.getSession().createCriteria(QuserImpl.class);
             if (pageNumber > 0 && pageSize > 0)
             {
                 criteria.setFirstResult(this.calculateFirstResult(pageNumber, pageSize));
                 criteria.setMaxResults(pageSize);
             }
             final Collection<?> results = criteria.list();
             this.transformEntities(transform, results);
             return results;
         }
         catch (HibernateException ex)
         {
             throw ex;
         }
     }
 
     /**
      * firstResult = (pageNumber - 1) * pageSize
      * @param pageNumber
      * @param pageSize
      * @return firstResult
      */
     protected int calculateFirstResult(int pageNumber, int pageSize)
     {
         int firstResult = 0;
         if (pageNumber > 0)
         {
             firstResult = (pageNumber - 1) * pageSize;
         }
         return firstResult;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Quser create(Quser quser)
     {
         return (Quser)this.create(QuserDao.TRANSFORM_NONE, quser);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Object create(final int transform, final Quser quser)
     {
         if (quser == null)
         {
             throw new IllegalArgumentException(
                 "Quser.create - 'quser' can not be null");
         }
         this.getSessionFactory().getCurrentSession().save(quser);
         return this.transformEntity(transform, quser);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({"unchecked"})
     public Collection<Quser> create(final Collection<Quser> entities)
     {
         return (Collection<Quser>) create(QuserDao.TRANSFORM_NONE, entities);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Collection<?> create(final int transform, final Collection<Quser> entities)
     {
         if (entities == null)
         {
             throw new IllegalArgumentException(
                 "Quser.create - 'entities' can not be null");
         }
                     for (Quser entity : entities)
                     {
                         create(transform, entity);
                     }
         return entities;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Quser create(
         String quserCd,
         String quserLastNm,
         String quserFirstNm,
         String quserIntranetLg,
         String quserExtranetLg,
         String quserEMail,
         String quserAddress,
         String quserPhone,
         String quserOrgan,
         String quserAdminCenter,
         String quserSite,
         String quserLdapPresent,
         String quserCryptPassword,
         Date quserCreationDt,
         Timestamp updateDt)
     {
         return (Quser)this.create(QuserDao.TRANSFORM_NONE, quserCd, quserLastNm, quserFirstNm, quserIntranetLg, quserExtranetLg, quserEMail, quserAddress, quserPhone, quserOrgan, quserAdminCenter, quserSite, quserLdapPresent, quserCryptPassword, quserCreationDt, updateDt);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Object create(
         final int transform,
         String quserCd,
         String quserLastNm,
         String quserFirstNm,
         String quserIntranetLg,
         String quserExtranetLg,
         String quserEMail,
         String quserAddress,
         String quserPhone,
         String quserOrgan,
         String quserAdminCenter,
         String quserSite,
         String quserLdapPresent,
         String quserCryptPassword,
         Date quserCreationDt,
         Timestamp updateDt)
     {
         Quser entity = new QuserImpl();
         entity.setQuserCd(quserCd);
         entity.setQuserLastNm(quserLastNm);
         entity.setQuserFirstNm(quserFirstNm);
         entity.setQuserIntranetLg(quserIntranetLg);
         entity.setQuserExtranetLg(quserExtranetLg);
         entity.setQuserEMail(quserEMail);
         entity.setQuserAddress(quserAddress);
         entity.setQuserPhone(quserPhone);
         entity.setQuserOrgan(quserOrgan);
         entity.setQuserAdminCenter(quserAdminCenter);
         entity.setQuserSite(quserSite);
         entity.setQuserLdapPresent(quserLdapPresent);
         
         entity.setQuserCreationDt(quserCreationDt);
         entity.setUpdateDt(updateDt);
         return this.create(transform, entity);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Quser create(
         String quserFirstNm,
         String quserIntranetLg,
         String quserLastNm,
         Timestamp updateDt,
         Department department,
         Status status)
     {
         return (Quser)this.create(QuserDao.TRANSFORM_NONE, quserFirstNm, quserIntranetLg, quserLastNm, updateDt, department, status);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Object create(
         final int transform,
         String quserFirstNm,
         String quserIntranetLg,
         String quserLastNm,
         Timestamp updateDt,
         Department department,
         Status status)
     {
         Quser entity = new QuserImpl();
         entity.setQuserFirstNm(quserFirstNm);
         entity.setQuserIntranetLg(quserIntranetLg);
         entity.setQuserLastNm(quserLastNm);
         entity.setUpdateDt(updateDt);
         entity.setDepartment(department);
         entity.setStatus(status);
         return this.create(transform, entity);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void update(Quser quser)
     {
         if (quser == null)
         {
             throw new IllegalArgumentException(
                 "Quser.update - 'quser' can not be null");
         }
         this.getSessionFactory().getCurrentSession().update(quser);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void update(final Collection<Quser> entities)
     {
         if (entities == null)
         {
             throw new IllegalArgumentException(
                 "Quser.update - 'entities' can not be null");
         }
                     for (Quser entity : entities)
                     {
                         update(entity);
                     }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove(Quser quser)
     {
         if (quser == null)
         {
             throw new IllegalArgumentException(
                 "Quser.remove - 'quser' can not be null");
         }
         this.getSessionFactory().getCurrentSession().delete(quser);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove(Integer quserId)
     {
         if (quserId == null)
         {
             throw new IllegalArgumentException(
                 "Quser.remove - 'quserId' can not be null");
         }
         Quser entity = this.get(quserId);
         if (entity != null)
         {
             this.remove(entity);
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void remove(Collection<Quser> entities)
     {
         if (entities == null)
         {
             throw new IllegalArgumentException(
                 "Quser.remove - 'entities' can not be null");
         }
         deleteAll(entities);
     }
     /**
      * Allows transformation of entities into value objects
      * (or something else for that matter), when the <code>transform</code>
      * flag is set to one of the constants defined in <code>QuserDao</code>, please note
      * that the {@link #TRANSFORM_NONE} constant denotes no transformation, so the entity itself
      * will be returned.
      * <p>
      * This method will return instances of these types:
      * <ul>
      *   <li>{@link Quser} - {@link #TRANSFORM_NONE}</li>
      *   <li>{@link QuserVO} - {@link #TRANSFORM_QUSERVO}</li>
      *   <li>{@link LightQuserVO} - {@link #TRANSFORM_LIGHTQUSERVO}</li>
      * </ul>
      *
      * If the integer argument value is unknown {@link #TRANSFORM_NONE} is assumed.
      *
      * @param transform one of the constants declared in {@link QuserDao}
      * @param entity an entity that was found
      * @return the transformed entity (i.e. new value object, etc)
      * @see QuserDao#transformEntity(int, Quser)
      */
     public Object transformEntity(final int transform, final Quser entity)
     {
         Object target = null;
         if (entity != null)
         {
             switch (transform)
             {
                 case TRANSFORM_QUSERVO :
                     target = toQuserVO(entity);
                     break;
                 case TRANSFORM_LIGHTQUSERVO :
                     target = toLightQuserVO(entity);
                     break;
                 case QuserDao.TRANSFORM_NONE : // fall-through
                 default:
                     target = entity;
             }
         }
         return target;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void transformEntities(final int transform, final Collection<?> entities)
     {
         switch (transform)
         {
             case TRANSFORM_QUSERVO :
                 toQuserVOCollection(entities);
                 break;
             case TRANSFORM_LIGHTQUSERVO :
                 toLightQuserVOCollection(entities);
                 break;
             case QuserDao.TRANSFORM_NONE : // fall-through
                 default:
                 // do nothing;
         }
     }
 
     /**
      * @see QuserDao#toEntities(Collection)
      */
     public void toEntities(final Collection<?> results)
     {
         if (results != null)
         {
             CollectionUtils.transform(results, this.ENTITYTRANSFORMER);
         }
     }
 
     /**
      * This anonymous transformer is designed to transform report query results
      * (which result in an array of entities) to {@link Quser}
      * using the Jakarta Commons-Collections Transformation API.
      */
     private Transformer ENTITYTRANSFORMER =
         new Transformer()
         {
             public Object transform(Object input)
             {
                 Object result = null;
                 if (input instanceof Object[])
                 {
                     result = toEntity((Object[])input);
                 }
                 else if (input instanceof Quser)
                 {
                     result = input;
                 }
                 return result;
             }
         };
 
     /**
      * @param row
      * @return Quser
      */
     protected Quser toEntity(Object[] row)
     {
         Quser target = null;
         if (row != null)
         {
             final int numberOfObjects = row.length;
             for (int ctr = 0; ctr < numberOfObjects; ctr++)
             {
                 final Object object = row[ctr];
                 if (object instanceof Quser)
                 {
                     target = (Quser)object;
                     break;
                 }
             }
         }
         return target;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({"unchecked"})
     public final Collection<QuserVO> toQuserVOCollection(Collection<?> entities)
     {
         Collection<QuserVO> result = new ArrayList<QuserVO>();
         if (entities != null)
         {
             CollectionUtils.transform(entities, this.QUSERVO_TRANSFORMER);
             result.addAll((Collection<? extends QuserVO>) entities);
         }
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({ "unchecked" })
     public final QuserVO[] toQuserVOArray(Collection<?> entities)
     {
         QuserVO[] result = null;
         if (entities != null)
         {
             // Unchecked transformation: reuses entities Collection
             final Collection collection = new ArrayList(entities);
             this.toQuserVOCollection(collection);
             result = (QuserVO[]) collection.toArray(new QuserVO[collection.size()]);
         }
         return result;
     }
 
     /**
      * Default implementation for transforming the results of a report query into a value object. This
      * implementation exists for convenience reasons only. It needs only be overridden in the
      * {@link QuserDaoImpl} class if you intend to use reporting queries.
      * @param row
      * @return toQuserVO(this.toEntity(row))
      * @see QuserDao#toQuserVO(Quser)
      */
     protected QuserVO toQuserVO(Object[] row)
     {
         return this.toQuserVO(this.toEntity(row));
     }
 
     /**
      * This anonymous transformer is designed to transform entities or report query results
      * (which result in an array of objects) to {@link QuserVO}
      * using the Jakarta Commons-Collections Transformation API.
      */
     private Transformer QUSERVO_TRANSFORMER =
         new Transformer()
         {
             public Object transform(Object input)
             {
                 Object result = null;
                 if (input instanceof Quser)
                 {
                     result = toQuserVO((Quser)input);
                 }
                 else if (input instanceof Object[])
                 {
                     result = toQuserVO((Object[])input);
                 }
                 return result;
             }
         };
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final void quserVOToEntityCollection(Collection<?> instances)
     {
         if (instances != null)
         {
             for (final Iterator<?> iterator = instances.iterator(); iterator.hasNext();)
             {
                 // - remove an objects that are null or not of the correct instance
                 if (!(iterator.next() instanceof QuserVO))
                 {
                     iterator.remove();
                 }
             }
             CollectionUtils.transform(instances, this.QuserVOToEntityTransformer);
         }
     }
 
     private final Transformer QuserVOToEntityTransformer =
         new Transformer()
         {
             public Object transform(Object input)
             {
                 return quserVOToEntity((QuserVO)input);
             }
         };
 
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void toQuserVO(
         Quser source,
         QuserVO target)
     {
         target.setQuserId(source.getQuserId());
         target.setQuserCd(source.getQuserCd());
         target.setQuserLastNm(source.getQuserLastNm());
         target.setQuserFirstNm(source.getQuserFirstNm());
         target.setQuserIntranetLg(source.getQuserIntranetLg());
         target.setQuserExtranetLg(source.getQuserExtranetLg());
         target.setQuserEMail(source.getQuserEMail());
         target.setQuserAddress(source.getQuserAddress());
         target.setQuserPhone(source.getQuserPhone());
         target.setQuserOrgan(source.getQuserOrgan());
         target.setQuserAdminCenter(source.getQuserAdminCenter());
         target.setQuserSite(source.getQuserSite());
         target.setQuserLdapPresent(source.getQuserLdapPresent());
         target.setQuserCreationDt(source.getQuserCreationDt());
         target.setUpdateDt(source.getUpdateDt());
         // No conversion for target.department (can't convert source.getDepartment():Department to fr.ifremer.quadrige2.core.vo.administration.user.DepartmentVO)
         // No conversion for target.privileges (can't convert source.getPrivileges():fr.ifremer.quadrige2.core.dao.referential.Privilege to fr.ifremer.quadrige2.core.vo.administration.user.PrivilegeVO)
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public QuserVO toQuserVO(final Quser entity)
     {
         QuserVO target = null;
         if (entity != null)
         {
             target =  new QuserVO();
             this.toQuserVO(entity, target);
         }
         return target;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void quserVOToEntity(
         QuserVO source,
         Quser target,
         boolean copyIfNull)
     {
         if (copyIfNull || source.getQuserCd() != null)
         {
             target.setQuserCd(source.getQuserCd());
         }
         if (copyIfNull || source.getQuserLastNm() != null)
         {
             target.setQuserLastNm(source.getQuserLastNm());
         }
         if (copyIfNull || source.getQuserFirstNm() != null)
         {
             target.setQuserFirstNm(source.getQuserFirstNm());
         }
         if (copyIfNull || source.getQuserIntranetLg() != null)
         {
             target.setQuserIntranetLg(source.getQuserIntranetLg());
         }
         if (copyIfNull || source.getQuserExtranetLg() != null)
         {
             target.setQuserExtranetLg(source.getQuserExtranetLg());
         }
         if (copyIfNull || source.getQuserEMail() != null)
         {
             target.setQuserEMail(source.getQuserEMail());
         }
         if (copyIfNull || source.getQuserAddress() != null)
         {
             target.setQuserAddress(source.getQuserAddress());
         }
         if (copyIfNull || source.getQuserPhone() != null)
         {
             target.setQuserPhone(source.getQuserPhone());
         }
         if (copyIfNull || source.getQuserOrgan() != null)
         {
             target.setQuserOrgan(source.getQuserOrgan());
         }
         if (copyIfNull || source.getQuserAdminCenter() != null)
         {
             target.setQuserAdminCenter(source.getQuserAdminCenter());
         }
         if (copyIfNull || source.getQuserSite() != null)
         {
             target.setQuserSite(source.getQuserSite());
         }
         if (copyIfNull || source.getQuserLdapPresent() != null)
         {
             target.setQuserLdapPresent(source.getQuserLdapPresent());
         }
         if (copyIfNull || source.getQuserCreationDt() != null)
         {
             target.setQuserCreationDt(source.getQuserCreationDt());
         }
         if (copyIfNull || source.getUpdateDt() != null)
         {
             target.setUpdateDt(source.getUpdateDt());
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({"unchecked"})
     public final Collection<LightQuserVO> toLightQuserVOCollection(Collection<?> entities)
     {
         Collection<LightQuserVO> result = new ArrayList<LightQuserVO>();
         if (entities != null)
         {
             CollectionUtils.transform(entities, this.LIGHTQUSERVO_TRANSFORMER);
             result.addAll((Collection<? extends LightQuserVO>) entities);
         }
         return result;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({ "unchecked" })
     public final LightQuserVO[] toLightQuserVOArray(Collection<?> entities)
     {
         LightQuserVO[] result = null;
         if (entities != null)
         {
             // Unchecked transformation: reuses entities Collection
             final Collection collection = new ArrayList(entities);
             this.toLightQuserVOCollection(collection);
             result = (LightQuserVO[]) collection.toArray(new LightQuserVO[collection.size()]);
         }
         return result;
     }
 
     /**
      * Default implementation for transforming the results of a report query into a value object. This
      * implementation exists for convenience reasons only. It needs only be overridden in the
      * {@link QuserDaoImpl} class if you intend to use reporting queries.
      * @param row
      * @return toLightQuserVO(this.toEntity(row))
      * @see QuserDao#toLightQuserVO(Quser)
      */
     protected LightQuserVO toLightQuserVO(Object[] row)
     {
         return this.toLightQuserVO(this.toEntity(row));
     }
 
     /**
      * This anonymous transformer is designed to transform entities or report query results
      * (which result in an array of objects) to {@link LightQuserVO}
      * using the Jakarta Commons-Collections Transformation API.
      */
     private Transformer LIGHTQUSERVO_TRANSFORMER =
         new Transformer()
         {
             public Object transform(Object input)
             {
                 Object result = null;
                 if (input instanceof Quser)
                 {
                     result = toLightQuserVO((Quser)input);
                 }
                 else if (input instanceof Object[])
                 {
                     result = toLightQuserVO((Object[])input);
                 }
                 return result;
             }
         };
 
     /**
      * {@inheritDoc}
      */
     @Override
     public final void lightQuserVOToEntityCollection(Collection<?> instances)
     {
         if (instances != null)
         {
             for (final Iterator<?> iterator = instances.iterator(); iterator.hasNext();)
             {
                 // - remove an objects that are null or not of the correct instance
                 if (!(iterator.next() instanceof LightQuserVO))
                 {
                     iterator.remove();
                 }
             }
             CollectionUtils.transform(instances, this.LightQuserVOToEntityTransformer);
         }
     }
 
     private final Transformer LightQuserVOToEntityTransformer =
         new Transformer()
         {
             public Object transform(Object input)
             {
                 return lightQuserVOToEntity((LightQuserVO)input);
             }
         };
 
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void toLightQuserVO(
         Quser source,
         LightQuserVO target)
     {
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public LightQuserVO toLightQuserVO(final Quser entity)
     {
         LightQuserVO target = null;
         if (entity != null)
         {
             target =  new LightQuserVO();
             this.toLightQuserVO(entity, target);
         }
         return target;
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public void lightQuserVOToEntity(
         LightQuserVO source,
         Quser target,
         boolean copyIfNull)
     {
     }
 
     /**
      * Gets the current <code>principal</code> if one has been set,
      * otherwise returns <code>null</code>.
      *
      * @return the current principal
      */
     protected Principal getPrincipal()
     {
         return PrincipalStore.get();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings({ "unchecked" })
     public PaginationResult search(final int transform, final int pageNumber, final int pageSize, final Search search)
     {
         try
         {
             search.setPageNumber(pageNumber);
             search.setPageSize(pageSize);
             final PropertySearch propertySearch = new PropertySearch(
                 this.getSession(), QuserImpl.class, search);
             final List results = propertySearch.executeAsList();
             this.transformEntities(transform, results);
             return new PaginationResult(results.toArray(new Object[results.size()]), propertySearch.getTotalCount());
         }
         catch (HibernateException ex)
         {
             throw ex; /*super.convertHibernateAccessException(ex);*/
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public PaginationResult search(final int pageNumber, final int pageSize, final Search search)
     {
         return this.search(QuserDao.TRANSFORM_NONE, pageNumber, pageSize, search);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public Set<?> search(final int transform, final Search search)
     {
         try
         {
             final PropertySearch propertySearch = new PropertySearch(
                 this.getSession(), QuserImpl.class, search);
             final Set<?> results = propertySearch.executeAsSet();
             this.transformEntities(transform, results);
             return results;
         }
         catch (HibernateException ex)
         {
             throw ex; /*super.convertHibernateAccessException(ex);*/
         }
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     @SuppressWarnings("unchecked")
     public Set<Quser> search(final Search search)
     {
         return (Set<Quser>) this.search(QuserDao.TRANSFORM_NONE, search);
     }
 
     /**
      * Executes and returns the given Hibernate queryObject as a {@link PaginationResult} instance.
      * @param queryObject
      * @param transform
      * @param pageNumber
      * @param pageSize
      * @return PaginationResult
      */
     @SuppressWarnings({ "unchecked" })
     protected PaginationResult getPaginationResult(
         final Query queryObject,
         final int transform, int pageNumber, int pageSize)
     {
         try
         {
             final ScrollableResults scrollableResults = queryObject.scroll();
             scrollableResults.last();
             int totalCount = scrollableResults.getRowNumber();
             totalCount = totalCount >= 0 ? totalCount + 1 : 0;
             if (pageNumber > 0 && pageSize > 0)
             {
                 queryObject.setFirstResult(this.calculateFirstResult(pageNumber, pageSize));
                 queryObject.setMaxResults(pageSize);
             }
             // Unchecked transformation because Set object is reused, cannot be strongly typed.
             Set results = new LinkedHashSet(queryObject.list());
             transformEntities(transform, results);
             return new PaginationResult(results.toArray(new Object[results.size()]), totalCount);
         }
         catch (HibernateException ex)
         {
             throw ex; /*super.convertHibernateAccessException(ex);*/
         }
     }
 
     // spring-hibernate-dao-base merge-point
 }