eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java

   1 // $Id$
   2 /**
   3  * Copyright (C) 2013 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 package eu.etaxonomy.taxeditor.editor.view.dataimport.transientServices;
  11
  12 import java.io.IOException;
  13 import java.util.Collection;
  14 import java.util.EnumSet;
  15 import java.util.List;
  16 import java.util.Map;
  17 import java.util.Set;
  18 import java.util.UUID;
  19
  20 import org.apache.lucene.index.CorruptIndexException;
  21 import org.apache.lucene.queryparser.classic.ParseException;
  22 import org.hibernate.LockOptions;
  23 import org.hibernate.Session;
  24 import org.hibernate.criterion.Criterion;
  25 import org.hibernate.envers.query.criteria.AuditCriterion;
  26
  27 import eu.etaxonomy.cdm.api.service.DeleteResult;
  28 import eu.etaxonomy.cdm.api.service.ITaxonService;
  29 import eu.etaxonomy.cdm.api.service.TaxaAndNamesSearchMode;
  30 import eu.etaxonomy.cdm.api.service.UpdateResult;
  31 import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
  32 import eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator;
  33 import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
  34 import eu.etaxonomy.cdm.api.service.config.IncludedTaxonConfiguration;
  35 import eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator;
  36 import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
  37 import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
  38 import eu.etaxonomy.cdm.api.service.dto.IdentifiedEntityDTO;
  39 import eu.etaxonomy.cdm.api.service.dto.IncludedTaxaDTO;
  40 import eu.etaxonomy.cdm.api.service.dto.MarkedEntityDTO;
  41 import eu.etaxonomy.cdm.api.service.exception.DataChangeNoRollbackException;
  42 import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
  43 import eu.etaxonomy.cdm.api.service.pager.Pager;
  44 import eu.etaxonomy.cdm.api.service.search.LuceneMultiSearchException;
  45 import eu.etaxonomy.cdm.api.service.search.SearchResult;
  46 import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge;
  47 import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
  48 import eu.etaxonomy.cdm.model.common.Annotation;
  49 import eu.etaxonomy.cdm.model.common.DefinedTerm;
  50 import eu.etaxonomy.cdm.model.common.ISourceable;
  51 import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
  52 import eu.etaxonomy.cdm.model.common.IdentifiableSource;
  53 import eu.etaxonomy.cdm.model.common.LSID;
  54 import eu.etaxonomy.cdm.model.common.Language;
  55 import eu.etaxonomy.cdm.model.common.Marker;
  56 import eu.etaxonomy.cdm.model.common.MarkerType;
  57 import eu.etaxonomy.cdm.model.common.RelationshipBase;
  58 import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
  59 import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
  60 import eu.etaxonomy.cdm.model.description.Feature;
  61 import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
  62 import eu.etaxonomy.cdm.model.location.NamedArea;
  63 import eu.etaxonomy.cdm.model.media.Media;
  64 import eu.etaxonomy.cdm.model.media.MediaRepresentation;
  65 import eu.etaxonomy.cdm.model.media.Rights;
  66 import eu.etaxonomy.cdm.model.name.HomotypicalGroup;
  67 import eu.etaxonomy.cdm.model.name.Rank;
  68 import eu.etaxonomy.cdm.model.name.TaxonNameBase;
  69 import eu.etaxonomy.cdm.model.reference.Reference;
  70 import eu.etaxonomy.cdm.model.taxon.Classification;
  71 import eu.etaxonomy.cdm.model.taxon.Synonym;
  72 import eu.etaxonomy.cdm.model.taxon.SynonymRelationship;
  73 import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
  74 import eu.etaxonomy.cdm.model.taxon.Taxon;
  75 import eu.etaxonomy.cdm.model.taxon.TaxonBase;
  76 import eu.etaxonomy.cdm.model.taxon.TaxonNode;
  77 import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
  78 import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
  79 import eu.etaxonomy.cdm.model.view.AuditEvent;
  80 import eu.etaxonomy.cdm.model.view.AuditEventRecord;
  81 import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
  82 import eu.etaxonomy.cdm.persistence.dto.MergeResult;
  83 import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
  84 import eu.etaxonomy.cdm.persistence.query.Grouping;
  85 import eu.etaxonomy.cdm.persistence.query.MatchMode;
  86 import eu.etaxonomy.cdm.persistence.query.OrderHint;
  87 import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;
  88 import eu.etaxonomy.cdm.strategy.match.IMatchStrategy;
  89 import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy;
  90
  91 /**
  92  * @author pplitzner
  93  * @date 27.09.2013
  94  *
  95  */
  96 public class TransientTaxonService implements ITaxonService {
  97
  98     private final ITaxonService defaultService;
  99
 100     /**
 101      * @param defaultTaxonService
 102      */
 103     public TransientTaxonService(ITaxonService defaultTaxonService) {
 104         this.defaultService = defaultTaxonService;
 105     }
 106
 107     /**
 108      * @param t
 109      * @param pageSize
 110      * @param pageNumber
 111      * @param sort
 112      * @param propertyPaths
 113      * @return
 114      * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(eu.etaxonomy.cdm.model.common.VersionableEntity, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List)
 115      */
 116     @Override
 117     public Pager<AuditEventRecord<TaxonBase>> pageAuditEvents(TaxonBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
 118         return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
 119     }
 120
 121     /**
 122      * @param annotatedObj
 123      * @param status
 124      * @param pageSize
 125      * @param pageNumber
 126      * @param orderHints
 127      * @param propertyPaths
 128      * @return
 129      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getAnnotations(eu.etaxonomy.cdm.model.common.AnnotatableEntity, eu.etaxonomy.cdm.model.common.MarkerType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 130      */
 131     @Override
 132     public Pager<Annotation> getAnnotations(TaxonBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 133         return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
 134     }
 135
 136     /**
 137      *
 138      * @see eu.etaxonomy.cdm.api.service.IService#clear()
 139      */
 140     @Override
 141     public void clear() {
 142         defaultService.clear();
 143     }
 144
 145     /**
 146      * @param t
 147      * @param lockMode
 148      * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode)
 149      */
 150     @Override
 151     public void lock(TaxonBase t, LockOptions lockOptions) {
 152         defaultService.lock(t, lockOptions);
 153     }
 154
 155     /**
 156      * @param t
 157      * @param lockMode
 158      * @param propertyPaths
 159      * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List)
 160      */
 161     @Override
 162     public void refresh(TaxonBase t, LockOptions lockOptions, List<String> propertyPaths) {
 163         defaultService.refresh(t, lockOptions, propertyPaths);
 164     }
 165
 166     /**
 167      *
 168      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache()
 169      */
 170     @Override
 171     public void updateTitleCache() {
 172         defaultService.updateTitleCache();
 173     }
 174
 175     /**
 176      * @param t
 177      * @return
 178      * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity)
 179      */
 180     @Override
 181     public AuditEventRecord<TaxonBase> getNextAuditEvent(TaxonBase t) {
 182         return defaultService.getNextAuditEvent(t);
 183     }
 184
 185     /**
 186      * @param annotatableEntity
 187      * @param technical
 188      * @param pageSize
 189      * @param pageNumber
 190      * @param orderHints
 191      * @param propertyPaths
 192      * @return
 193      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#getMarkers(eu.etaxonomy.cdm.model.common.AnnotatableEntity, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 194      */
 195     @Override
 196     public Pager<Marker> getMarkers(TaxonBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 197         return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
 198     }
 199
 200     /**
 201      * @param clazz
 202      * @param stepSize
 203      * @param cacheStrategy
 204      * @param monitor
 205      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache(java.lang.Class, java.lang.Integer, eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy, eu.etaxonomy.cdm.common.monitor.IProgressMonitor)
 206      */
 207     @Override
 208     public void updateTitleCache(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {
 209         defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
 210     }
 211
 212     /**
 213      * @param t
 214      * @return
 215      * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity)
 216      */
 217     @Override
 218     public AuditEventRecord<TaxonBase> getPreviousAuditEvent(TaxonBase t) {
 219         return defaultService.getPreviousAuditEvent(t);
 220     }
 221
 222     /**
 223      * @param clazz
 224      * @return
 225      * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class)
 226      */
 227     @Override
 228     public int count(Class<? extends TaxonBase> clazz) {
 229         return defaultService.count(clazz);
 230     }
 231
 232     /**
 233      * @param clazz
 234      * @param from
 235      * @param to
 236      * @param criteria
 237      * @param pageSize
 238      * @param pageValue
 239      * @param sort
 240      * @param propertyPaths
 241      * @return
 242      * @see eu.etaxonomy.cdm.api.service.IVersionableService#pageAuditEvents(java.lang.Class, eu.etaxonomy.cdm.model.view.AuditEvent, eu.etaxonomy.cdm.model.view.AuditEvent, java.util.List, java.lang.Integer, java.lang.Integer, eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort, java.util.List)
 243      */
 244     @Override
 245     public Pager<AuditEventRecord<TaxonBase>> pageAuditEvents(Class<? extends TaxonBase> clazz, AuditEvent from, AuditEvent to, List<AuditCriterion> criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List<String> propertyPaths) {
 246         return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
 247     }
 248
 249     /**
 250      * @param lsid
 251      * @return
 252      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID)
 253      */
 254     @Override
 255     public TaxonBase find(LSID lsid) {
 256         return defaultService.find(lsid);
 257     }
 258
 259     /**
 260      * @param persistentObject
 261      * @return
 262      * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase)
 263      */
 264     @Override
 265     public DeleteResult delete(TaxonBase persistentObject) {
 266         return defaultService.delete(persistentObject);
 267     }
 268
 269     /**
 270      * @param clazz
 271      * @param technical
 272      * @param pageSize
 273      * @param pageNumber
 274      * @param propertyPaths
 275      * @return
 276      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List)
 277      */
 278     @Override
 279     public List<Object[]> groupMarkers(Class<? extends TaxonBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 280         return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
 281     }
 282
 283     /**
 284      * @param uuid
 285      * @return
 286      * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID)
 287      */
 288     @Override
 289     public boolean exists(UUID uuid) {
 290         return defaultService.exists(uuid);
 291     }
 292
 293
 294     /**
 295      * @param x
 296      * @param y
 297      * @return
 298      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity)
 299      */
 300     @Override
 301     public TaxonBase replace(TaxonBase x, TaxonBase y) {
 302         return defaultService.replace(x, y);
 303     }
 304
 305     /**
 306      * @param uuidSet
 307      * @return
 308      * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set)
 309      */
 310     @Override
 311     public List<TaxonBase> find(Set<UUID> uuidSet) {
 312         return defaultService.find(uuidSet);
 313     }
 314
 315     /**
 316      * @param t
 317      * @param pageSize
 318      * @param pageNumber
 319      * @param propertyPaths
 320      * @return
 321      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List)
 322      */
 323     @Override
 324     public Pager<IdentifiableSource> getSources(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 325         return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
 326     }
 327
 328     /**
 329      * @param uuid
 330      * @return
 331      * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID)
 332      */
 333     @Override
 334     public TaxonBase find(UUID uuid) {
 335         return defaultService.find(uuid);
 336     }
 337
 338     /**
 339      * @param id
 340      * @return
 341      * @see eu.etaxonomy.cdm.api.service.IService#find(int)
 342      */
 343     @Override
 344     public TaxonBase find(int id) {
 345         return defaultService.find(id);
 346     }
 347
 348     /**
 349      * @param t
 350      * @param pageSize
 351      * @param pageNumber
 352      * @param propertyPaths
 353      * @return
 354      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List)
 355      */
 356     @Override
 357     public Pager<Rights> getRights(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
 358         return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
 359     }
 360
 361     /**
 362      * @param clazz
 363      * @param technical
 364      * @return
 365      * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean)
 366      */
 367     @Override
 368     public int countMarkers(Class<? extends TaxonBase> clazz, Boolean technical) {
 369         return defaultService.countMarkers(clazz, technical);
 370     }
 371
 372     /**
 373      * @param idSet
 374      * @return
 375      * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set)
 376      */
 377     @Override
 378     public List<TaxonBase> findById(Set<Integer> idSet) {
 379         return defaultService.findById(idSet);
 380     }
 381
 382     /**
 383      * @param clazz
 384      * @param idInSource
 385      * @param idNamespace
 386      * @return
 387      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String)
 388      */
 389     @Override
 390     public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
 391         return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
 392     }
 393
 394     /**
 395      * @return
 396      * @see eu.etaxonomy.cdm.api.service.IService#getSession()
 397      */
 398     @Override
 399     public Session getSession() {
 400         return defaultService.getSession();
 401     }
 402
 403     /**
 404      * @param clazz
 405      * @param limit
 406      * @param start
 407      * @param groups
 408      * @param propertyPaths
 409      * @return
 410      * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 411      */
 412     @Override
 413     public List<Object[]> group(Class<? extends TaxonBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
 414         return defaultService.group(clazz, limit, start, groups, propertyPaths);
 415     }
 416
 417     /**
 418      * @param limit
 419      * @param start
 420      * @return
 421      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllRelationships(int, int)
 422      */
 423     @Override
 424     public List<RelationshipBase> getAllRelationships(int limit, int start) {
 425         return defaultService.getAllRelationships(limit, start);
 426     }
 427
 428     /**
 429      * @param clazz
 430      * @param queryString
 431      * @param matchmode
 432      * @param criteria
 433      * @param pageSize
 434      * @param pageNumber
 435      * @param orderHints
 436      * @param propertyPaths
 437      * @return
 438      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 439      */
 440     @Override
 441     public Pager<TaxonBase> findByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 442         return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 443     }
 444
 445     /**
 446      * @param name
 447      * @param sec
 448      * @return
 449      * @see eu.etaxonomy.cdm.api.service.ITaxonService#searchTaxaByName(java.lang.String, eu.etaxonomy.cdm.model.reference.Reference)
 450      */
 451     @Override
 452     public List<TaxonBase> searchTaxaByName(String name, Reference sec) {
 453         return defaultService.searchTaxaByName(name, sec);
 454     }
 455
 456
 457     /**
 458      * {@inheritDoc}
 459      */
 460     @Override
 461     public UpdateResult swapSynonymAndAcceptedTaxon(Synonym arg0, Taxon arg1) {
 462         return defaultService.swapSynonymAndAcceptedTaxon(arg0, arg1);
 463
 464     }
 465
 466     /**
 467      * @param type
 468      * @param limit
 469      * @param start
 470      * @param orderHints
 471      * @param propertyPaths
 472      * @return
 473      * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 474      */
 475     @Override
 476     public <S extends TaxonBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 477         return defaultService.list(type, limit, start, orderHints, propertyPaths);
 478     }
 479
 480     /**
 481      * @param configurator
 482      * @return
 483      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator)
 484      */
 485     @Override
 486     public Pager<TaxonBase> findByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
 487         return defaultService.findByTitle(configurator);
 488     }
 489
 490     /**
 491      * @param synonym
 492      * @param acceptedTaxon
 493      * @param deleteSynonym
 494      * @param copyCitationInfo
 495      * @param citation
 496      * @param microCitation
 497      * @return
 498      * @throws HomotypicalGroupChangeException
 499      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
 500      */
 501     @Override
 502     public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws HomotypicalGroupChangeException {
 503         return defaultService.changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, deleteSynonym, copyCitationInfo, citation, microCitation);
 504     }
 505
 506     /**
 507      * @param clazz
 508      * @param queryString
 509      * @param matchmode
 510      * @param criteria
 511      * @return
 512      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List)
 513      */
 514     @Override
 515     public Integer countByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
 516         return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
 517     }
 518
 519     /**
 520      * @param uuid
 521      * @return
 522      * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID)
 523      */
 524     @Override
 525     public TaxonBase load(UUID uuid) {
 526         return defaultService.load(uuid);
 527     }
 528
 529     /**
 530      * @param uuid
 531      * @param propertyPaths
 532      * @return
 533      * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List)
 534      */
 535     @Override
 536     public TaxonBase load(UUID uuid, List<String> propertyPaths) {
 537         return defaultService.load(uuid, propertyPaths);
 538     }
 539
 540     /**
 541      * @param configurator
 542      * @return
 543      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator)
 544      */
 545     @Override
 546     public Integer countByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
 547         return defaultService.countByTitle(configurator);
 548     }
 549
 550     /**
 551      * @param transientObject
 552      * @return
 553      * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase)
 554      */
 555     @Override
 556     public TaxonBase merge(TaxonBase transientObject) {
 557         return defaultService.merge(transientObject);
 558     }
 559
 560     /**
 561      * @param clazz
 562      * @param queryString
 563      * @param matchmode
 564      * @param criteria
 565      * @param pageSize
 566      * @param pageNumber
 567      * @param orderHints
 568      * @param propertyPaths
 569      * @return
 570      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 571      */
 572     @Override
 573     public List<TaxonBase> listByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 574         return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 575     }
 576
 577     /**
 578      * @param type
 579      * @param pageSize
 580      * @param pageNumber
 581      * @param orderHints
 582      * @param propertyPaths
 583      * @return
 584      * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 585      */
 586     @Override
 587     public  <S extends TaxonBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 588         return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
 589     }
 590
 591     /**
 592      * @param persistentObject
 593      * @return
 594      * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase)
 595      */
 596     @Override
 597     public UUID refresh(TaxonBase persistentObject) {
 598         return defaultService.refresh(persistentObject);
 599     }
 600
 601     /**
 602      * @param synonym
 603      * @param toTaxon
 604      * @param taxonRelationshipType
 605      * @param reference
 606      * @param microReference
 607      * @return
 608      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToRelatedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
 609      */
 610     @Override
 611     public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference reference, String microReference) {
 612         return defaultService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference);
 613     }
 614
 615     /**
 616      * @param clazz
 617      * @param queryString
 618      * @param matchmode
 619      * @param criteria
 620      * @param pageSize
 621      * @param pageNumber
 622      * @param orderHints
 623      * @param propertyPaths
 624      * @return
 625      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#listByReferenceTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 626      */
 627     @Override
 628     public List<TaxonBase> listByReferenceTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 629         return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
 630     }
 631
 632     /**
 633      * @param tableName
 634      * @param limit
 635      * @param start
 636      * @return
 637      * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int)
 638      */
 639     @Override
 640     public List<TaxonBase> rows(String tableName, int limit, int start) {
 641         return defaultService.rows(tableName, limit, start);
 642     }
 643
 644     /**
 645      * @param newInstances
 646      * @return
 647      * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection)
 648      */
 649     @Override
 650     public Map<UUID, TaxonBase> save(Collection<TaxonBase> newInstances) {
 651         return null;
 652     }
 653
 654     /**
 655      * @param newInstance
 656      * @return
 657      * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase)
 658      */
 659     @Override
 660     public TaxonBase save(TaxonBase newInstance) {
 661         return null;
 662     }
 663
 664     /**
 665      * @param transientObject
 666      * @return
 667      * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase)
 668      */
 669     @Override
 670     public UUID saveOrUpdate(TaxonBase transientObject) {
 671         return null;
 672     }
 673
 674     /**
 675      * @param synonym
 676      * @param newHomotypicalGroup
 677      * @param targetTaxon
 678      * @param removeFromOtherTaxa
 679      * @param setBasionymRelationIfApplicable
 680      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeHomotypicalGroupOfSynonym(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.name.HomotypicalGroup, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, boolean)
 681      */
 682     @Override
 683     public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon, boolean removeFromOtherTaxa, boolean setBasionymRelationIfApplicable) {
 684         defaultService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable);
 685     }
 686
 687     /**
 688      * @param transientObjects
 689      * @return
 690      * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection)
 691      */
 692     @Override
 693     public Map<UUID, TaxonBase> saveOrUpdate(Collection<TaxonBase> transientObjects) {
 694         return null;
 695     }
 696
 697     /**
 698      * @param transientObject
 699      * @return
 700      * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase)
 701      */
 702     @Override
 703     public UUID update(TaxonBase transientObject) {
 704         return defaultService.update(transientObject);
 705     }
 706
 707     /**
 708      * @param example
 709      * @param includeProperties
 710      * @param limit
 711      * @param start
 712      * @param orderHints
 713      * @param propertyPaths
 714      * @return
 715      * @see eu.etaxonomy.cdm.api.service.IService#list(eu.etaxonomy.cdm.model.common.ICdmBase, java.util.Set, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 716      */
 717     @Override
 718     public List<TaxonBase> list(TaxonBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
 719         return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
 720     }
 721
 722     /**
 723      * @param oldSynonymRelation
 724      * @param newTaxon
 725      * @param moveHomotypicGroup
 726      * @param newSynonymRelationshipType
 727      * @param newReference
 728      * @param newReferenceDetail
 729      * @param keepReference
 730      * @return
 731      * @throws HomotypicalGroupChangeException
 732      * @see eu.etaxonomy.cdm.api.service.ITaxonService#moveSynonymToAnotherTaxon(eu.etaxonomy.cdm.model.taxon.SynonymRelationship, eu.etaxonomy.cdm.model.taxon.Taxon, boolean, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String, boolean)
 733      */
 734     @Override
 735     public UpdateResult moveSynonymToAnotherTaxon(SynonymRelationship oldSynonymRelation, Taxon newTaxon, boolean moveHomotypicGroup, SynonymRelationshipType newSynonymRelationshipType, Reference newReference, String newReferenceDetail, boolean keepReference) throws HomotypicalGroupChangeException {
 736         return defaultService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);
 737     }
 738
 739     /**
 740      * @param clazz
 741      * @param matchStrategy
 742      * @param mergeStrategy
 743      * @return
 744      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy)
 745      */
 746     @Override
 747     public int deduplicate(Class<? extends TaxonBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
 748         return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
 749     }
 750
 751     /**
 752      * @param clazz
 753      * @param queryString
 754      * @param pageSize
 755      * @param pageNumber
 756      * @param orderHints
 757      * @param matchMode
 758      * @return
 759      * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findTitleCache(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, eu.etaxonomy.cdm.persistence.query.MatchMode)
 760      */
 761     @Override
 762     public Pager<TaxonBase> findTitleCache(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
 763         return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
 764     }
 765
 766     /**
 767      * @param taxon
 768      * @param type
 769      * @param pageSize
 770      * @param pageNumber
 771      * @param orderHints
 772      * @param propertyPaths
 773      * @return
 774      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 775      */
 776     @Override
 777     public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 778         return defaultService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
 779     }
 780
 781     /**
 782      * @param taxon
 783      * @param type
 784      * @param pageSize
 785      * @param pageNumber
 786      * @param orderHints
 787      * @param propertyPaths
 788      * @return
 789      * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageToTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 790      */
 791     @Override
 792     public Pager<TaxonRelationship> pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 793         return defaultService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
 794     }
 795
 796     /**
 797      * @param taxon
 798      * @param type
 799      * @param pageSize
 800      * @param pageNumber
 801      * @param orderHints
 802      * @param propertyPaths
 803      * @return
 804      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 805      */
 806     @Override
 807     public List<TaxonRelationship> listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 808         return defaultService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
 809     }
 810
 811     /**
 812      * @param taxon
 813      * @param type
 814      * @param pageSize
 815      * @param pageNumber
 816      * @param orderHints
 817      * @param propertyPaths
 818      * @return
 819      * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageFromTaxonRelationships(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 820      */
 821     @Override
 822     public Pager<TaxonRelationship> pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 823         return defaultService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
 824     }
 825
 826     /**
 827      * @param taxon
 828      * @param includeRelationships
 829      * @param maxDepth
 830      * @param limit
 831      * @param start
 832      * @param propertyPaths
 833      * @return
 834      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listRelatedTaxa(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Integer, java.lang.Integer, java.lang.Integer, java.util.List)
 835      */
 836     @Override
 837     public Set<Taxon> listRelatedTaxa(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Integer maxDepth, Integer limit, Integer start, List<String> propertyPaths) {
 838         return defaultService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths);
 839     }
 840
 841     /**
 842      * @param taxonBase
 843      * @param limit
 844      * @param start
 845      * @param propertyPaths
 846      * @return
 847      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listClassifications(eu.etaxonomy.cdm.model.taxon.TaxonBase, java.lang.Integer, java.lang.Integer, java.util.List)
 848      */
 849     @Override
 850     public List<Classification> listClassifications(TaxonBase taxonBase, Integer limit, Integer start, List<String> propertyPaths) {
 851         return defaultService.listClassifications(taxonBase, limit, start, propertyPaths);
 852     }
 853
 854     /**
 855      * @param synonym
 856      * @param type
 857      * @param pageSize
 858      * @param pageNumber
 859      * @param orderHints
 860      * @param propertyPaths
 861      * @return
 862      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 863      */
 864     @Override
 865     public Pager<SynonymRelationship> getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 866         return defaultService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths);
 867     }
 868
 869     /**
 870      * @param taxon
 871      * @param type
 872      * @param pageSize
 873      * @param pageNumber
 874      * @param orderHints
 875      * @param propertyPaths
 876      * @return
 877      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 878      */
 879     @Override
 880     public Pager<SynonymRelationship> getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 881         return defaultService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
 882     }
 883
 884     /**
 885      * @param taxon
 886      * @param propertyPaths
 887      * @return
 888      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHomotypicSynonymsByHomotypicGroup(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)
 889      */
 890     @Override
 891     public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
 892         return defaultService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths);
 893     }
 894
 895     /**
 896      * @param taxon
 897      * @param propertyPaths
 898      * @return
 899      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getHeterotypicSynonymyGroups(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.List)
 900      */
 901     @Override
 902     public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths) {
 903         return defaultService.getHeterotypicSynonymyGroups(taxon, propertyPaths);
 904     }
 905
 906     /**
 907      * @param clazz
 908      * @param queryString
 909      * @param pageSize
 910      * @param pageNumber
 911      * @param orderHints
 912      * @param propertyPaths
 913      * @return
 914      * @see eu.etaxonomy.cdm.api.service.ITaxonService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 915      */
 916     @Override
 917     public Pager<TaxonBase> search(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
 918         return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
 919     }
 920
 921     /**
 922      * @param clazz
 923      * @param uninomial
 924      * @param infragenericEpithet
 925      * @param specificEpithet
 926      * @param infraspecificEpithet
 927      * @param rank
 928      * @param pageSize
 929      * @param pageNumber
 930      * @return
 931      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer)
 932      */
 933     @Override
 934     public Pager<TaxonBase> findTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, String authorship, Rank rank, Integer pageSize, Integer pageNumber) {
 935         return defaultService.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, authorship, rank, pageSize, pageNumber);
 936     }
 937
 938     /**
 939      * @param clazz
 940      * @param uninomial
 941      * @param infragenericEpithet
 942      * @param specificEpithet
 943      * @param infraspecificEpithet
 944      * @param rank
 945      * @param pageSize
 946      * @param pageNumber
 947      * @return
 948      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxaByName(java.lang.Class, java.lang.String, java.lang.String, java.lang.String, java.lang.String, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer)
 949      */
 950     @Override
 951     public List<TaxonBase> listTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, String authorship, Rank rank, Integer pageSize, Integer pageNumber) {
 952         return defaultService.listTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, authorship, rank, pageSize, pageNumber);
 953     }
 954
 955     /**
 956      * @param configurator
 957      * @return
 958      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNames(eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator)
 959      */
 960     @Override
 961     public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {
 962         return defaultService.findTaxaAndNames(configurator);
 963     }
 964
 965     /**
 966      * @param queryString
 967      * @param classification
 968      * @param languages
 969      * @param highlightFragments
 970      * @param pageSize
 971      * @param pageNumber
 972      * @param orderHints
 973      * @param propertyPaths
 974      * @return
 975      * @throws CorruptIndexException
 976      * @throws IOException
 977      * @throws ParseException
 978      * @throws LuceneMultiSearchException
 979      * @deprecated
 980      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByEverythingFullText(java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
 981      */
 982     @Deprecated
 983     @Override
 984     public Pager<SearchResult<TaxonBase>> findByEverythingFullText(String queryString, Classification classification, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
 985         return defaultService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
 986     }
 987
 988     /**
 989      * @param clazz
 990      * @param queryString
 991      * @param classification
 992      * @param languages
 993      * @param highlightFragments
 994      * @param pageSize
 995      * @param pageNumber
 996      * @param orderHints
 997      * @param propertyPaths
 998      * @return
 999      * @throws CorruptIndexException
1000      * @throws IOException
1001      * @throws ParseException
1002      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1003      */
1004     @Override
1005     public Pager<SearchResult<TaxonBase>> findByFullText(Class<? extends TaxonBase> clazz, String queryString, Classification classification, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException {
1006         return defaultService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
1007     }
1008
1009
1010     /* (non-Javadoc)
1011      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByDistribution(java.util.List, java.util.List, eu.etaxonomy.cdm.model.taxon.Classification, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1012      */
1013     @Override
1014     public Pager<SearchResult<TaxonBase>> findByDistribution(List<NamedArea> areaFilter,
1015             List<PresenceAbsenceTerm> statusFilter, Classification classification, Integer pageSize,
1016             Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException,
1017             ParseException {
1018         return defaultService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
1019     }
1020
1021
1022     /* (non-Javadoc)
1023      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesByFullText(java.util.EnumSet, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.Set, java.util.Set, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1024      */
1025     @Override
1026     public Pager<SearchResult<TaxonBase>> findTaxaAndNamesByFullText(EnumSet<TaxaAndNamesSearchMode> searchModes,
1027             String queryString, Classification classification, Set<NamedArea> namedAreas,
1028             Set<PresenceAbsenceTerm> distributionStatus, List<Language> languages, boolean highlightFragments,
1029             Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths)
1030                     throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
1031         return defaultService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
1032     }
1033
1034     /**
1035      * @param clazz
1036      * @param queryString
1037      * @param classification
1038      * @param features
1039      * @param languages
1040      * @param highlightFragments
1041      * @param pageSize
1042      * @param pageNumber
1043      * @param orderHints
1044      * @param propertyPaths
1045      * @return
1046      * @throws CorruptIndexException
1047      * @throws IOException
1048      * @throws ParseException
1049      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByDescriptionElementFullText(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, java.util.List, boolean, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1050      */
1051     @Override
1052     public Pager<SearchResult<TaxonBase>> findByDescriptionElementFullText(Class<? extends DescriptionElementBase> clazz, String queryString, Classification classification, List<Feature> features, List<Language> languages, boolean highlightFragments, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws CorruptIndexException, IOException, ParseException {
1053         return defaultService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
1054     }
1055
1056     /**
1057      * @param taxon
1058      * @param size
1059      * @param height
1060      * @param widthOrDuration
1061      * @param mimeTypes
1062      * @return
1063      * @deprecated
1064      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getAllMedia(eu.etaxonomy.cdm.model.taxon.Taxon, int, int, int, java.lang.String[])
1065      */
1066     @Deprecated
1067     @Override
1068     public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes) {
1069         return defaultService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes);
1070     }
1071
1072     /**
1073      * @param taxon
1074      * @param includeRelationships
1075      * @param limitToGalleries
1076      * @param propertyPath
1077      * @return
1078      * @deprecated
1079      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listTaxonDescriptionMedia(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, boolean, java.util.List)
1080      */
1081     @Deprecated
1082     @Override
1083     public List<Media> listTaxonDescriptionMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, boolean limitToGalleries, List<String> propertyPath) {
1084         return defaultService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath);
1085     }
1086
1087     /**
1088      * @param taxon
1089      * @param includeRelationships
1090      * @param limitToGalleries
1091      * @param includeTaxonDescriptions
1092      * @param includeOccurrences
1093      * @param includeTaxonNameDescriptions
1094      * @param propertyPath
1095      * @return
1096      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listMedia(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.Set, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.lang.Boolean, java.util.List)
1097      */
1098     @Override
1099     public List<Media> listMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences, Boolean includeTaxonNameDescriptions, List<String> propertyPath) {
1100         return defaultService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath);
1101     }
1102
1103     /**
1104      * @param listOfIDs
1105      * @return
1106      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByID(java.util.Set)
1107      */
1108     @Override
1109     public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {
1110         return defaultService.findTaxaByID(listOfIDs);
1111     }
1112
1113     /**
1114      * @param uuid
1115      * @param propertyPaths
1116      * @return
1117      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxonByUuid(java.util.UUID, java.util.List)
1118      */
1119     @Override
1120     public TaxonBase findTaxonByUuid(UUID uuid, List<String> propertyPaths) {
1121         return defaultService.findTaxonByUuid(uuid, propertyPaths);
1122     }
1123
1124     /**
1125      * @return
1126      * @see eu.etaxonomy.cdm.api.service.ITaxonService#countAllRelationships()
1127      */
1128     @Override
1129     public int countAllRelationships() {
1130         return defaultService.countAllRelationships();
1131     }
1132
1133     /**
1134      * @param propertyPath
1135      * @return
1136      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNames(java.util.List)
1137      */
1138     @Override
1139     public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {
1140         return defaultService.findIdenticalTaxonNames(propertyPath);
1141     }
1142
1143     /**
1144      * @param propertyPath
1145      * @return
1146      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findIdenticalTaxonNameIds(java.util.List)
1147      */
1148     @Override
1149     public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {
1150         return defaultService.findIdenticalTaxonNameIds(propertyPath);
1151     }
1152
1153     /**
1154      * @param name
1155      * @return
1156      * @see eu.etaxonomy.cdm.api.service.ITaxonService#getPhylumName(eu.etaxonomy.cdm.model.name.TaxonNameBase)
1157      */
1158     @Override
1159     public String getPhylumName(TaxonNameBase name) {
1160         return defaultService.getPhylumName(name);
1161     }
1162
1163     /**
1164      * @param syn
1165      * @return
1166      * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonymRelationships(eu.etaxonomy.cdm.model.taxon.Synonym)
1167      */
1168     @Override
1169     public long deleteSynonymRelationships(Synonym syn) {
1170         return defaultService.deleteSynonymRelationships(syn);
1171     }
1172
1173     /**
1174      * @param taxonBase
1175      * @param type
1176      * @param pageSize
1177      * @param pageNumber
1178      * @param orderHints
1179      * @param propertyPaths
1180      * @param direction
1181      * @return
1182      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listSynonymRelationships(eu.etaxonomy.cdm.model.taxon.TaxonBase, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List, eu.etaxonomy.cdm.model.common.RelationshipBase.Direction)
1183      */
1184     @Override
1185     public List<SynonymRelationship> listSynonymRelationships(TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths, Direction direction) {
1186         return defaultService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction);
1187     }
1188
1189     /**
1190      * @param taxonName
1191      * @return
1192      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(java.lang.String)
1193      */
1194     @Override
1195     public Taxon findBestMatchingTaxon(String taxonName) {
1196         return defaultService.findBestMatchingTaxon(taxonName);
1197     }
1198
1199     /**
1200      * @param config
1201      * @return
1202      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingTaxon(eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator)
1203      */
1204     @Override
1205     public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) {
1206         return defaultService.findBestMatchingTaxon(config);
1207     }
1208
1209     /**
1210      * @param taxonName
1211      * @return
1212      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findBestMatchingSynonym(java.lang.String)
1213      */
1214     @Override
1215     public Synonym findBestMatchingSynonym(String taxonName) {
1216         return defaultService.findBestMatchingSynonym(taxonName);
1217     }
1218
1219
1220     /**
1221      * @param configurator
1222      * @return
1223      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesForEditor(eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator)
1224      */
1225     @Override
1226     public List<UuidAndTitleCache<IdentifiableEntity>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator configurator) {
1227         return defaultService.findTaxaAndNamesForEditor(configurator);
1228     }
1229
1230     /**
1231      * @param taxon
1232      * @param tree
1233      * @param type
1234      * @param doWithMisappliedNames
1235      * @return
1236      * @see eu.etaxonomy.cdm.api.service.ITaxonService#createInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType, boolean)
1237      */
1238     @Override
1239     public List<Synonym> createInferredSynonyms(Taxon taxon, Classification tree, SynonymRelationshipType type, boolean doWithMisappliedNames) {
1240         return defaultService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames);
1241     }
1242
1243     /**
1244      * @param taxon
1245      * @param tree
1246      * @param doWithMisappliedNames
1247      * @return
1248      * @see eu.etaxonomy.cdm.api.service.ITaxonService#createAllInferredSynonyms(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, boolean)
1249      */
1250     @Override
1251     public List<Synonym> createAllInferredSynonyms(Taxon taxon, Classification tree, boolean doWithMisappliedNames) {
1252         return defaultService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames);
1253     }
1254
1255     @Override
1256     public DeleteResult deleteSynonym(Synonym arg0, SynonymDeletionConfigurator arg1) {
1257         return defaultService.deleteSynonym(arg0, arg1);
1258     }
1259
1260     @Override
1261     public DeleteResult deleteSynonym(Synonym arg0, Taxon arg1, SynonymDeletionConfigurator arg2) {
1262         return defaultService.deleteSynonym(arg0, arg1, arg2);
1263     }
1264
1265     @Override
1266     public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
1267         return defaultService.getSynonymsByHomotypicGroup(taxon, propertyPaths);
1268     }
1269
1270     @Override
1271     public Synonym changeRelatedTaxonToSynonym(Taxon fromTaxon, Taxon toTaxon,
1272             TaxonRelationshipType oldRelationshipType,
1273             SynonymRelationshipType synonymRelationshipType)
1274                     throws DataChangeNoRollbackException {
1275
1276         return defaultService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
1277     }
1278
1279     /* (non-Javadoc)
1280      * @see eu.etaxonomy.cdm.api.service.ITaxonService#pageAcceptedTaxaFor(java.util.UUID, java.util.UUID, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1281      */
1282     @Override
1283     public Pager<Taxon> pageAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
1284             Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
1285         return defaultService.pageAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
1286     }
1287
1288     /* (non-Javadoc)
1289      * @see eu.etaxonomy.cdm.api.service.ITaxonService#listAcceptedTaxaFor(java.util.UUID, java.util.UUID, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List)
1290      */
1291     @Override
1292     public List<Taxon> listAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
1293             Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
1294         return defaultService.listAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
1295     }
1296
1297     @Override
1298     public DeleteResult isDeletable(TaxonBase object,
1299             DeleteConfiguratorBase config) {
1300         // TODO Auto-generated method stub
1301         return null;
1302     }
1303
1304     @Override
1305     public IncludedTaxaDTO listIncludedTaxa(UUID taxonUuid,
1306             IncludedTaxonConfiguration configuration) {
1307         // TODO Auto-generated method stub
1308         return null;
1309     }
1310
1311     @Override
1312     public TaxonBase findWithoutFlush(UUID uuid) {
1313         return defaultService.findWithoutFlush(uuid);
1314     }
1315
1316     /* (non-Javadoc)
1317      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByName(eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator)
1318      */
1319     @Override
1320     public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config) {
1321         return defaultService.findTaxaByName(config);
1322     }
1323
1324     @Override
1325     public <S extends TaxonBase>  Pager<IdentifiedEntityDTO<S>> findByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeEntity, Integer pageSize, Integer pageNumber, List<String> propertyPaths){
1326         return defaultService.findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
1327     }
1328
1329     /* (non-Javadoc)
1330      * @see eu.etaxonomy.cdm.api.service.ITaxonService#findByIdentifier(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.model.common.DefinedTerm, eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.persistence.query.MatchMode, boolean, java.lang.Integer, java.lang.Integer, java.util.List)
1331      */
1332     @Override
1333     public <S extends TaxonBase> Pager<IdentifiedEntityDTO<S>> findByIdentifier(Class<S> clazz, String identifier,
1334             DefinedTerm identifierType, TaxonNode subtreeFilter, MatchMode matchmode, boolean includeEntity,
1335             Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
1336         return defaultService.findByIdentifier(clazz, identifier, identifierType, subtreeFilter, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
1337     }
1338
1339
1340
1341     /* (non-Javadoc)
1342      * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(java.util.UUID, java.util.UUID, eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator)
1343      */
1344     @Override
1345     public DeleteResult deleteSynonym(UUID synonymUuid, UUID taxonUuid, SynonymDeletionConfigurator config) {
1346         return defaultService.deleteSynonym(synonymUuid, taxonUuid, config);
1347     }
1348
1349
1350     /**
1351      * {@inheritDoc}
1352
1353      */
1354     @Override
1355     public UpdateResult swapSynonymAndAcceptedTaxon(UUID synonymUUid, UUID acceptedTaxonUuid) {
1356         return defaultService.swapSynonymAndAcceptedTaxon(synonymUUid, acceptedTaxonUuid);
1357     }
1358
1359     /* (non-Javadoc)
1360      * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteTaxon(java.util.UUID, eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator, java.util.UUID)
1361      */
1362     @Override
1363     public DeleteResult deleteTaxon(UUID taxonUuid, TaxonDeletionConfigurator config, UUID classificationUuid) {
1364         return defaultService.deleteTaxon(taxonUuid, config, classificationUuid);
1365     }
1366
1367
1368         @Override
1369         public UpdateResult moveFactualDateToAnotherTaxon(UUID arg0, UUID arg1) {
1370                 return defaultService.moveFactualDateToAnotherTaxon(arg0, arg1);
1371         }
1372
1373
1374     /**
1375      * {@inheritDoc}
1376      */
1377     @Override
1378     public UpdateResult moveSynonymToAnotherTaxon(
1379             SynonymRelationship oldSynonymRelation, UUID newTaxonUUID,
1380             boolean moveHomotypicGroup,
1381             SynonymRelationshipType newSynonymRelationshipType,
1382             Reference reference, String referenceDetail, boolean keepReference)
1383                     throws HomotypicalGroupChangeException {
1384
1385         return defaultService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxonUUID, moveHomotypicGroup, newSynonymRelationshipType, reference, referenceDetail, keepReference);
1386     }
1387
1388
1389     /* (non-Javadoc)
1390      * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.UUID)
1391      */
1392     @Override
1393     public DeleteResult delete(UUID uuid) {
1394         return defaultService.delete(uuid);
1395
1396     }
1397
1398     /* (non-Javadoc)
1399      * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.Collection)
1400      */
1401     @Override
1402     public DeleteResult delete(Collection<UUID> arg0) {
1403         return defaultService.delete(arg0);
1404     }
1405
1406     /* (non-Javadoc)
1407      * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List)
1408      */
1409     @Override
1410     public List<TaxonBase> merge(List<TaxonBase> arg0) {
1411         return defaultService.merge(arg0);
1412     }
1413
1414     /* (non-Javadoc)
1415      * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(java.util.UUID, eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator)
1416      */
1417     @Override
1418     public DeleteResult deleteSynonym(UUID arg0, SynonymDeletionConfigurator arg1) {
1419         return defaultService.deleteSynonym(arg0, arg1);
1420     }
1421
1422     /* (non-Javadoc)
1423      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToRelatedTaxon(java.util.UUID, java.util.UUID, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
1424      */
1425     @Override
1426     public UpdateResult changeSynonymToRelatedTaxon(UUID arg0, UUID arg1, TaxonRelationshipType arg2, Reference arg3,
1427             String arg4) {
1428         return defaultService.changeSynonymToRelatedTaxon(arg0, arg1, arg2, arg3, arg4);
1429     }
1430
1431     /* (non-Javadoc)
1432      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeRelatedTaxonToSynonym(java.util.UUID, java.util.UUID, eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType, eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType)
1433      */
1434     @Override
1435     public UpdateResult changeRelatedTaxonToSynonym(UUID arg0, UUID arg1, TaxonRelationshipType arg2,
1436             SynonymRelationshipType arg3) throws DataChangeNoRollbackException {
1437         return defaultService.changeRelatedTaxonToSynonym(arg0, arg1, arg2, arg3);
1438
1439     }
1440
1441     /* (non-Javadoc)
1442      * @see eu.etaxonomy.cdm.api.service.ITaxonService#changeSynonymToAcceptedTaxon(java.util.UUID, java.util.UUID, java.util.UUID, boolean, boolean, eu.etaxonomy.cdm.model.reference.Reference, java.lang.String)
1443      */
1444     @Override
1445     public UpdateResult changeSynonymToAcceptedTaxon(UUID arg0, UUID arg1, UUID arg2, boolean arg3, boolean arg4,
1446             Reference arg5, String arg6) throws HomotypicalGroupChangeException {
1447         return defaultService.changeSynonymToAcceptedTaxon(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
1448     }
1449
1450     /* (non-Javadoc)
1451      * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
1452      */
1453     @Override
1454     public List<MergeResult<TaxonBase>> merge(List<TaxonBase> arg0, boolean arg1) {
1455         return defaultService.merge(arg0, arg1);
1456     }
1457
1458     /* (non-Javadoc)
1459      * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
1460      */
1461     @Override
1462     public MergeResult<TaxonBase> merge(TaxonBase arg0, boolean arg1) {
1463         return defaultService.merge(arg0, arg1);
1464     }
1465
1466     /* (non-Javadoc)
1467      * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
1468      */
1469     @Override
1470     public TaxonBase loadWithUpdate(UUID arg0) {
1471         return defaultService.loadWithUpdate(arg0);
1472     }
1473
1474     /**
1475      * {@inheritDoc}
1476      */
1477     @Override
1478     public List<TaxonBase> load(List<UUID> arg0, List<String> arg1) {
1479         return defaultService.load(arg0, arg1);
1480     }
1481
1482         @Override
1483         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCache(
1484                         Integer limit, String pattern) {
1485                 return defaultService.getUuidAndTitleCache(limit, pattern);
1486         }
1487
1488         @Override
1489         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheTaxon(
1490                         Integer limit, String pattern) {
1491                 return defaultService.getUuidAndTitleCacheTaxon(limit, pattern);
1492         }
1493
1494         @Override
1495         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheSynonym(
1496                         Integer limit, String pattern) {
1497                 return defaultService.getUuidAndTitleCacheSynonym(limit, pattern);
1498         }
1499
1500         @Override
1501         public List<TaxonBase> loadByIds(List<Integer> idSet, List<String> propertyPaths) {
1502
1503                 return defaultService.loadByIds(idSet, propertyPaths);
1504         }
1505
1506         @Override
1507         public <S extends TaxonBase> Pager<MarkedEntityDTO<S>> findByMarker(
1508                         Class<S> clazz, MarkerType type, Boolean value, TaxonNode subtree,
1509                         boolean includeEntity, Integer size, Integer limit, List<String> path) {
1510                 return defaultService.findByMarker(clazz, type, value, subtree, includeEntity, size, limit, path);
1511         }
1512
1513         @Override
1514         public <S extends TaxonBase> Pager<MarkedEntityDTO<S>> findByMarker(
1515                         Class<S> arg0, MarkerType arg1, Boolean arg2, boolean arg3,
1516                         Integer arg4, Integer arg5, List<String> arg6) {
1517                 // TODO Auto-generated method stub
1518                 return null;
1519         }
1520
1521
1522 }