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