cdmlib-services/src/main/java/eu/etaxonomy/cdm/api/service/IdentifiableServiceBase.java

   1 // $Id$
   2 /**
   3 * Copyright (C) 2007 EDIT
   4 * European Distributed Institute of Taxonomy
   5 * http://www.e-taxonomy.eu
   6 *
   7 * The contents of this file are subject to the Mozilla Public License Version 1.1
   8 * See LICENSE.TXT at the top of this package for the full license terms.
   9 */
  10
  11 package eu.etaxonomy.cdm.api.service;
  12
  13 import java.util.ArrayList;
  14 import java.util.Arrays;
  15 import java.util.HashMap;
  16 import java.util.HashSet;
  17 import java.util.List;
  18 import java.util.Map;
  19 import java.util.Set;
  20
  21 import org.apache.log4j.Logger;
  22 import org.hibernate.criterion.Criterion;
  23 import org.springframework.transaction.annotation.Transactional;
  24
  25 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
  26 import eu.etaxonomy.cdm.api.service.pager.Pager;
  27 import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;
  28 import eu.etaxonomy.cdm.common.monitor.DefaultProgressMonitor;
  29 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  30 import eu.etaxonomy.cdm.model.common.CdmBase;
  31 import eu.etaxonomy.cdm.model.common.ISourceable;
  32 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  33 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  34 import eu.etaxonomy.cdm.model.common.LSID;
  35 import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
  36 import eu.etaxonomy.cdm.model.media.Rights;
  37 import eu.etaxonomy.cdm.model.name.NonViralName;
  38 import eu.etaxonomy.cdm.model.reference.Reference;
  39 import eu.etaxonomy.cdm.model.reference.ReferenceFactory;
  40 import eu.etaxonomy.cdm.persistence.dao.common.IIdentifiableDao;
  41 import eu.etaxonomy.cdm.persistence.dao.hibernate.HibernateBeanInitializer;
  42 import eu.etaxonomy.cdm.persistence.dao.initializer.AutoPropertyInitializer;
  43 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  44 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  45 import eu.etaxonomy.cdm.persistence.query.OrderHint.SortOrder;
  46 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  47 import eu.etaxonomy.cdm.strategy.match.DefaultMatchStrategy;
  48 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  49 import eu.etaxonomy.cdm.strategy.match.IMatchable;
  50 import eu.etaxonomy.cdm.strategy.match.MatchException;
  51 import eu.etaxonomy.cdm.strategy.merge.IMergable;
  52 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  53 import eu.etaxonomy.cdm.strategy.merge.MergeException;
  54
  55 public abstract class IdentifiableServiceBase<T extends IdentifiableEntity,DAO extends IIdentifiableDao<T>> extends AnnotatableServiceBase<T,DAO>
  56                                                 implements IIdentifiableEntityService<T>{
  57
  58 //    @Autowired
  59 //    protected ICommonService commonService;
  60
  61
  62         protected static final int UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE = 1000;
  63         protected static final  Logger logger = Logger.getLogger(IdentifiableServiceBase.class);
  64
  65         @Transactional(readOnly = true)
  66         public Pager<Rights> getRights(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
  67         Integer numberOfResults = dao.countRights(t);
  68
  69                 List<Rights> results = new ArrayList<Rights>();
  70                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  71                         results = dao.getRights(t, pageSize, pageNumber,propertyPaths);
  72                 }
  73
  74                 return new DefaultPagerImpl<Rights>(pageNumber, numberOfResults, pageSize, results);
  75         }
  76
  77         @Transactional(readOnly = true)
  78         public Pager<IdentifiableSource> getSources(T t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
  79                  Integer numberOfResults = dao.countSources(t);
  80
  81                         List<IdentifiableSource> results = new ArrayList<IdentifiableSource>();
  82                         if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
  83                                 results = dao.getSources(t, pageSize, pageNumber,propertyPaths);
  84                         }
  85
  86                         return new DefaultPagerImpl<IdentifiableSource>(pageNumber, numberOfResults, pageSize, results);
  87         }
  88
  89
  90         @Transactional(readOnly = false)
  91         public T replace(T x, T y) {
  92                 return dao.replace(x, y);
  93         }
  94         /**
  95          * FIXME Candidate for harmonization
  96          * Given that this method is strongly typed, and generic, could we not simply expose it as
  97          * List<T> findByTitle(String title) as it is somewhat less cumbersome. Admittedly, I don't
  98          * understand what is going on with the configurators etc. so maybe there is a good reason for
  99          * the design of this method.
 100          * @param title
 101          * @return
 102          */
 103         @Transactional(readOnly = true)
 104         protected List<T> findCdmObjectsByTitle(String title){
 105                 return ((IIdentifiableDao)dao).findByTitle(title);
 106         }
 107
 108         @Transactional(readOnly = true)
 109         protected List<T> findCdmObjectsByTitle(String title, Class<T> clazz){
 110                 return ((IIdentifiableDao)dao).findByTitleAndClass(title, clazz);
 111         }
 112         @Transactional(readOnly = true)
 113         protected List<T> findCdmObjectsByTitle(String title, CdmBase sessionObject){
 114                 return ((IIdentifiableDao)dao).findByTitle(title, sessionObject);
 115         }
 116
 117         /*
 118          * TODO - Migrated from CommonServiceBase
 119          *  (non-Javadoc)
 120          * @see eu.etaxonomy.cdm.api.service.ICommonService#getSourcedObjectById(java.lang.String, java.lang.String)
 121          */
 122         @Transactional(readOnly = true)
 123         public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
 124                 ISourceable result = null;
 125
 126                 List<T> list = dao.findOriginalSourceByIdInSource(idInSource, idNamespace);
 127                 if (! list.isEmpty()){
 128                         result = list.get(0);
 129                 }
 130                 return result;
 131         }
 132
 133         /* (non-Javadoc)
 134          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getUuidAndTitleCache()
 135          */
 136         @Transactional(readOnly = true)
 137         public List<UuidAndTitleCache<T>> getUuidAndTitleCache() {
 138                 return dao.getUuidAndTitleCache();
 139         }
 140
 141         @Transactional(readOnly = true)
 142         public Pager<T> findByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 143                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 144
 145                  List<T> results = new ArrayList<T>();
 146                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 147                                 results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 148                  }
 149
 150                   return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 151         }
 152
 153         @Transactional(readOnly = true)
 154         public Pager<T> findByTitle(IIdentifiableEntityServiceConfigurator<T> config){
 155                 return findByTitle(config.getClazz(), config.getTitleSearchStringSqlized(), config.getMatchMode(), config.getCriteria(), config.getPageSize(), config.getPageNumber(), config.getOrderHints(), config.getPropertyPaths());
 156         }
 157
 158         @Transactional(readOnly = true)
 159         public List<T> listByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 160                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 161
 162                  List<T> results = new ArrayList<T>();
 163                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 164                                 results = dao.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 165                  }
 166                  return results;
 167         }
 168
 169         @Transactional(readOnly = true)
 170         public Pager<T> findTitleCache(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode){
 171                 long numberOfResults = dao.countTitleCache(clazz, queryString, matchMode);
 172
 173                  List<T> results = new ArrayList<T>();
 174                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 175                                 results = dao.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
 176                  }
 177                  int r = 0;
 178                  r += numberOfResults;
 179
 180                   return new DefaultPagerImpl<T>(pageNumber, r , pageSize, results);
 181         }
 182
 183         @Transactional(readOnly = true)
 184         public List<T> listByReferenceTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 185                  Integer numberOfResults = dao.countByReferenceTitle(clazz, queryString, matchmode, criteria);
 186
 187                  List<T> results = new ArrayList<T>();
 188                  if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 189                                 results = dao.findByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 190                  }
 191                  return results;
 192         }
 193
 194         @Transactional(readOnly = true)
 195         public T find(LSID lsid) {
 196                 return dao.find(lsid);
 197         }
 198
 199         @Transactional(readOnly = true)
 200         public Pager<T> search(Class<? extends T> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 201         Integer numberOfResults = dao.count(clazz,queryString);
 202
 203                 List<T> results = new ArrayList<T>();
 204                 if(numberOfResults > 0) { // no point checking again //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)
 205                         results = dao.search(clazz,queryString, pageSize, pageNumber, orderHints, propertyPaths);
 206                 }
 207
 208                 return new DefaultPagerImpl<T>(pageNumber, numberOfResults, pageSize, results);
 209         }
 210
 211
 212         /* (non-Javadoc)
 213          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache()
 214          */
 215         @Override
 216         @Transactional(readOnly = false)
 217         public void updateTitleCache() {
 218                 updateTitleCache(null, null, null, null);
 219         }
 220
 221         @Transactional(readOnly = false)  //TODO check transactional behaviour, e.g. what happens with the session if count is very large
 222         protected <S extends T > void updateTitleCacheImpl(Class<S> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<T> cacheStrategy, IProgressMonitor monitor) {
 223                 if (stepSize == null){
 224                         stepSize = UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE;
 225                 }
 226                 if (monitor == null){
 227                         monitor = DefaultProgressMonitor.NewInstance();
 228                 }
 229
 230                 int count = dao.count(clazz);
 231                 monitor.beginTask("update titles", count);
 232                 int worked = 0;
 233                 for(int i = 0 ; i < count ; i = i + stepSize){
 234                         // not sure if such strict ordering is necessary here, but for safety reasons I do it
 235                         ArrayList<OrderHint> orderHints = new ArrayList<OrderHint>();
 236                         orderHints.add( new OrderHint("id", OrderHint.SortOrder.ASCENDING));
 237
 238
 239                         Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit = switchOfAutoinitializer();
 240                         List<S> list = this.list(clazz, stepSize, i, orderHints, null);
 241                         switchOnOldAutoInitializer(oldAutoInit);
 242
 243                         List<T> entitiesToUpdate = new ArrayList<T>();
 244                         for (T entity : list){
 245                                 if (entity.isProtectedTitleCache() == false){
 246                                         updateTitleCacheForSingleEntity(cacheStrategy, entitiesToUpdate, entity);
 247                                 }
 248                                 worked++;
 249                         }
 250                         for (T entity: entitiesToUpdate){
 251                                 if (entity.getTitleCache() != null){
 252                                         //System.err.println(entity.getTitleCache());
 253                                 }else{
 254                                         //System.err.println("no titleCache" + ((NonViralName)entity).getNameCache());
 255                                 }
 256                         }
 257                         saveOrUpdate(entitiesToUpdate);
 258                         monitor.worked(list.size());
 259                         if (monitor.isCanceled()){
 260                                 monitor.done();
 261                                 return;
 262                         }
 263                 }
 264                 monitor.done();
 265         }
 266
 267         /**
 268          * Brings back all auto initializers to the bean initializer
 269          * @see #switchOfAutoinitializer()
 270          * @param oldAutoInit
 271          */
 272         protected void switchOnOldAutoInitializer(
 273                         Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit) {
 274                 HibernateBeanInitializer initializer = (HibernateBeanInitializer)this.appContext.getBean("defaultBeanInitializer");
 275                 initializer.setBeanAutoInitializers(oldAutoInit);
 276         }
 277
 278         /**
 279          * Removes all auto initializers from the bean initializer
 280          *
 281          * @see #switchOnOldAutoInitializer(Map)
 282          * @return
 283          */
 284         protected Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> switchOfAutoinitializer() {
 285                 HibernateBeanInitializer initializer = (HibernateBeanInitializer)this.appContext.getBean("defaultBeanInitializer");
 286                 Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInitializers = initializer.getBeanAutoInitializers();
 287                 Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> map = new HashMap<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>>();
 288                 initializer.setBeanAutoInitializers(map);
 289                 return oldAutoInitializers;
 290         }
 291
 292         /**
 293          * @param cacheStrategy
 294          * @param entitiesToUpdate
 295          * @param entity
 296          */
 297         /**
 298          * @param cacheStrategy
 299          * @param entitiesToUpdate
 300          * @param entity
 301          */
 302         private void updateTitleCacheForSingleEntity(
 303                         IIdentifiableEntityCacheStrategy<T> cacheStrategy,
 304                         List<T> entitiesToUpdate, T entity) {
 305
 306                 assert (entity.isProtectedTitleCache() == false );
 307
 308                 //exclude recursive inreferences
 309                 if (entity.isInstanceOf(Reference.class)){
 310                         Reference<?> ref = CdmBase.deproxy(entity, Reference.class);
 311                         if (ref.getInReference() != null && ref.getInReference().equals(ref)){
 312                                 return;
 313                         }
 314                 }
 315
 316
 317                 //define the correct cache strategy
 318                 IIdentifiableEntityCacheStrategy entityCacheStrategy = cacheStrategy;
 319                 if (entityCacheStrategy == null){
 320                         entityCacheStrategy = entity.getCacheStrategy();
 321                         //FIXME find out why the wrong cache strategy is loaded here, see #1876
 322                         if (entity instanceof Reference){
 323                                 entityCacheStrategy = ReferenceFactory.newReference(((Reference)entity).getType()).getCacheStrategy();
 324                         }
 325                 }
 326                 entity.setCacheStrategy(entityCacheStrategy);
 327
 328
 329                 //old titleCache
 330                 entity.setProtectedTitleCache(true);
 331                 String oldTitleCache = entity.getTitleCache();
 332                 entity.setTitleCache(oldTitleCache, false);   //before we had entity.setProtectedTitleCache(false) but this deleted the titleCache itself
 333
 334                 //NonViralNames and Reference have more caches //TODO handle in NameService
 335                 String oldNameCache = null;
 336                 String oldFullTitleCache = null;
 337                 String oldAbbrevTitleCache = null;
 338                 if (entity instanceof NonViralName ){
 339                         NonViralName<?> nvn = (NonViralName) entity;
 340                         if (!nvn.isProtectedNameCache()){
 341                                 nvn.setProtectedNameCache(true);
 342                                 oldNameCache = nvn.getNameCache();
 343                                 nvn.setProtectedNameCache(false);
 344                         }
 345                         if (!nvn.isProtectedFullTitleCache()){
 346                                 nvn.setProtectedFullTitleCache(true);
 347                                 oldFullTitleCache = nvn.getFullTitleCache();
 348                                 nvn.setProtectedFullTitleCache(false);
 349                         }
 350                 }else if (entity instanceof Reference){
 351                         Reference<?> ref = (Reference<?>) entity;
 352                         if (!ref.isProtectedAbbrevTitleCache()){
 353                                 ref.setProtectedAbbrevTitleCache(true);
 354                                 oldAbbrevTitleCache = ref.getAbbrevTitleCache();
 355                                 ref.setProtectedAbbrevTitleCache(false);
 356                         }
 357                 }
 358                 setOtherCachesNull(entity); //TODO find better solution
 359
 360                 String newTitleCache = entityCacheStrategy.getTitleCache(entity);
 361                 if (oldTitleCache == null || oldTitleCache != null && ! oldTitleCache.equals(newTitleCache) ){
 362                         entity.setTitleCache(null, false);
 363                         String newCache = entity.getTitleCache();
 364                         if (newCache == null){
 365                                 logger.warn("newCache should never be null");
 366                         }
 367                         if (oldTitleCache == null){
 368                                 logger.info("oldTitleCache should never be null");
 369                         }
 370                         if (entity instanceof NonViralName){
 371                                 NonViralName<?> nvn = (NonViralName) entity;
 372                                 nvn.getNameCache();
 373                                 nvn.getFullTitleCache();
 374                         }
 375                         if (entity instanceof Reference){
 376                                 Reference<?> ref = (Reference<?>) entity;
 377                                 ref.getAbbrevTitleCache();
 378                         }
 379                         entitiesToUpdate.add(entity);
 380                 }else if (entity instanceof NonViralName){
 381                         NonViralName<?> nvn = (NonViralName) entity;
 382                         String newNameCache = nvn.getNameCache();
 383                         String newFullTitleCache = nvn.getFullTitleCache();
 384                         if (oldNameCache == null || (oldNameCache != null && !oldNameCache.equals(newNameCache))){
 385                                 entitiesToUpdate.add(entity);
 386                         }else if (oldFullTitleCache == null || (oldFullTitleCache != null && !oldFullTitleCache.equals(newFullTitleCache))){
 387                                 entitiesToUpdate.add(entity);
 388                         }
 389                 }else if (entity instanceof Reference){
 390                         Reference<?> ref = (Reference<?>) entity;
 391                         String newAbbrevTitleCache = ref.getAbbrevTitleCache();
 392                         if (oldAbbrevTitleCache == null || (oldAbbrevTitleCache != null && !oldAbbrevTitleCache.equals(newAbbrevTitleCache))){
 393                                 entitiesToUpdate.add(entity);
 394                         }
 395                 }
 396         }
 397
 398
 399
 400         /**
 401          * Needs override if not only the title cache should be set to null to
 402          * generate the correct new title cache
 403          */
 404         protected void setOtherCachesNull(T entity) {
 405                 return;
 406         }
 407
 408
 409
 410         private class DeduplicateState{
 411                 String lastTitleCache;
 412                 Integer pageSize = 50;
 413                 int nPages = 3;
 414                 int startPage = 0;
 415                 boolean isCompleted = false;
 416                 int result;
 417         }
 418
 419         /* (non-Javadoc)
 420          * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy)
 421          */
 422         @Override
 423         @Transactional(readOnly = false)
 424         public int deduplicate(Class<? extends T> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 425                 DeduplicateState dedupState = new DeduplicateState();
 426
 427                 if (clazz == null){
 428                         logger.warn("Deduplication clazz must not be null!");
 429                         return 0;
 430                 }
 431                 if (! ( IMatchable.class.isAssignableFrom(clazz) && IMergable.class.isAssignableFrom(clazz) )  ){
 432                         logger.warn("Deduplication implemented only for classes implementing IMatchable and IMergeable. No deduplication performed!");
 433                         return 0;
 434                 }
 435                 Class matchableClass = clazz;
 436                 if (matchStrategy == null){
 437                         matchStrategy = DefaultMatchStrategy.NewInstance(matchableClass);
 438                 }
 439                 List<T> nextGroup = new ArrayList<T>();
 440
 441                 int result = 0;
 442 //              double countTotal = count(clazz);
 443 //
 444 //              Number countPagesN = Math.ceil(countTotal/dedupState.pageSize.doubleValue()) ;
 445 //              int countPages = countPagesN.intValue();
 446 //
 447
 448                 List<OrderHint> orderHints = Arrays.asList(new OrderHint[]{new OrderHint("titleCache", SortOrder.ASCENDING)});
 449
 450                 while (! dedupState.isCompleted){
 451                         //get x page sizes
 452                         List<T> objectList = getPages(clazz, dedupState, orderHints);
 453                         //after each page check if any changes took place
 454                         int nUnEqualPages = handleAllPages(objectList, dedupState, nextGroup, matchStrategy, mergeStrategy);
 455                         nUnEqualPages = nUnEqualPages + dedupState.pageSize * dedupState.startPage;
 456                         //refresh start page counter
 457                         int finishedPages = nUnEqualPages / dedupState.pageSize;
 458                         dedupState.startPage = finishedPages;
 459                 }
 460
 461                 result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 462                 return result;
 463         }
 464
 465
 466         private int handleAllPages(List<T> objectList, DeduplicateState dedupState, List<T> nextGroup, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 467                 int nUnEqual = 0;
 468                 for (T object : objectList){
 469                         String currentTitleCache = object.getTitleCache();
 470                         if (currentTitleCache != null && currentTitleCache.equals(dedupState.lastTitleCache)){
 471                                 //=titleCache
 472                                 nextGroup.add(object);
 473                         }else{
 474                                 //<> titleCache
 475                                 dedupState.result += handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 476                                 nextGroup = new ArrayList<T>();
 477                                 nextGroup.add(object);
 478                                 nUnEqual++;
 479                         }
 480                         dedupState.lastTitleCache = currentTitleCache;
 481                 }
 482                 handleLastGroup(nextGroup, matchStrategy, mergeStrategy);
 483                 return nUnEqual;
 484         }
 485
 486         private List<T> getPages(Class<? extends T> clazz, DeduplicateState dedupState, List<OrderHint> orderHints) {
 487                 List<T> result = new ArrayList<T>();
 488                 for (int pageNo = dedupState.startPage; pageNo < dedupState.startPage + dedupState.nPages; pageNo++){
 489                         List<T> objectList = listByTitle(clazz, null, null, null, dedupState.pageSize, pageNo, orderHints, null);
 490                         result.addAll(objectList);
 491                 }
 492                 if (result.size()< dedupState.nPages * dedupState.pageSize ){
 493                         dedupState.isCompleted = true;
 494                 }
 495                 return result;
 496         }
 497
 498         private int handleLastGroup(List<T> group, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 499                 int result = 0;
 500                 int size = group.size();
 501                 Set<Integer> exclude = new HashSet<Integer>();  //set to collect all objects, that have been merged already
 502                 for (int i = 0; i < size - 1; i++){
 503                         if (exclude.contains(i)){
 504                                 continue;
 505                         }
 506                         for (int j = i + 1; j < size; j++){
 507                                 if (exclude.contains(j)){
 508                                         continue;
 509                                 }
 510                                 T firstObject = group.get(i);
 511                                 T secondObject = group.get(j);
 512
 513                                 try {
 514                                         if (matchStrategy.invoke((IMatchable)firstObject, (IMatchable)secondObject)){
 515                                                 commonService.merge((IMergable)firstObject, (IMergable)secondObject, mergeStrategy);
 516                                                 exclude.add(j);
 517                                                 result++;
 518                                         }
 519                                 } catch (MatchException e) {
 520                                         logger.warn("MatchException when trying to match " + firstObject.getTitleCache());
 521                                         e.printStackTrace();
 522                                 } catch (MergeException e) {
 523                                         logger.warn("MergeException when trying to merge " + firstObject.getTitleCache());
 524                                         e.printStackTrace();
 525                                 }
 526                         }
 527                 }
 528                 return result;
 529         }
 530
 531          public Integer countByTitle(Class<? extends T> clazz, String queryString,MatchMode matchmode, List<Criterion> criteria){
 532                  Integer numberOfResults = dao.countByTitle(clazz, queryString, matchmode, criteria);
 533
 534                  return numberOfResults;
 535          }
 536
 537         @Transactional(readOnly = true)
 538         public Integer countByTitle(IIdentifiableEntityServiceConfigurator<T> config){
 539                 return countByTitle(config.getClazz(), config.getTitleSearchStringSqlized(),
 540                                 config.getMatchMode(), config.getCriteria());
 541
 542         }
 543
 544
 545
 546
 547 }
 548