/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java - Diff - EDIT - EDIT Project Management

« Previous | Next »

Revision 7c1862cd

Added by Andreas Müller over 9 years ago

ID 7c1862cdb30110122030de2fca937b346592afb9
Parent 40125273
Child 71a98758

update Transient services

     import eu.etaxonomy.cdm.api.service.util.TaxonRelationshipEdge;
     import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;
     import eu.etaxonomy.cdm.model.common.Annotation;
     import eu.etaxonomy.cdm.model.common.DefinedTerm;
     import eu.etaxonomy.cdm.model.common.ISourceable;
     import eu.etaxonomy.cdm.model.common.IdentifiableEntity;
     import eu.etaxonomy.cdm.model.common.IdentifiableSource;
-...
      */
     public class TransientTaxonService implements ITaxonService {
         private final ITaxonService defaultTaxonService;
         private final ITaxonService defaultService;
         /**
          * @param defaultTaxonService
          */
         public TransientTaxonService(ITaxonService defaultTaxonService) {
             this.defaultTaxonService = defaultTaxonService;
             this.defaultService = defaultTaxonService;
+        }
         /**
-...
          */
         @Override
         public Pager<AuditEventRecord<TaxonBase>> pageAuditEvents(TaxonBase t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List<String> propertyPaths) {
             return defaultTaxonService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
             return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<Annotation> getAnnotations(TaxonBase annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public void clear() {
             defaultTaxonService.clear();
             defaultService.clear();
+        }
         /**
-...
          */
         @Override
         public void lock(TaxonBase t, LockOptions lockOptions) {
             defaultTaxonService.lock(t, lockOptions);
             defaultService.lock(t, lockOptions);
+        }
         /**
-...
          */
         @Override
         public void refresh(TaxonBase t, LockOptions lockOptions, List<String> propertyPaths) {
             defaultTaxonService.refresh(t, lockOptions, propertyPaths);
             defaultService.refresh(t, lockOptions, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public void updateTitleCache() {
             defaultTaxonService.updateTitleCache();
             defaultService.updateTitleCache();
+        }
         /**
-...
          */
         @Override
         public AuditEventRecord<TaxonBase> getNextAuditEvent(TaxonBase t) {
             return defaultTaxonService.getNextAuditEvent(t);
             return defaultService.getNextAuditEvent(t);
+        }
         /**
-...
          */
         @Override
         public Pager<Marker> getMarkers(TaxonBase annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public void updateTitleCache(Class<? extends TaxonBase> clazz, Integer stepSize, IIdentifiableEntityCacheStrategy<TaxonBase> cacheStrategy, IProgressMonitor monitor) {
             defaultTaxonService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
             defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor);
+        }
         /**
-...
          */
         @Override
         public AuditEventRecord<TaxonBase> getPreviousAuditEvent(TaxonBase t) {
             return defaultTaxonService.getPreviousAuditEvent(t);
             return defaultService.getPreviousAuditEvent(t);
+        }
         /**
-...
          */
         @Override
         public int count(Class<? extends TaxonBase> clazz) {
             return defaultTaxonService.count(clazz);
             return defaultService.count(clazz);
+        }
         /**
-...
          */
         @Override
         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) {
             return defaultTaxonService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
             return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public TaxonBase find(LSID lsid) {
             return defaultTaxonService.find(lsid);
             return defaultService.find(lsid);
+        }
         /**
-...
          */
         @Override
         public DeleteResult delete(TaxonBase persistentObject) {
             return defaultTaxonService.delete(persistentObject);
             return defaultService.delete(persistentObject);
+        }
         /**
-...
          */
         @Override
         public List<Object[]> groupMarkers(Class<? extends TaxonBase> clazz, Boolean technical, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
             return defaultTaxonService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
             return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public boolean exists(UUID uuid) {
             return defaultTaxonService.exists(uuid);
             return defaultService.exists(uuid);
+        }
-...
          */
         @Override
         public TaxonBase replace(TaxonBase x, TaxonBase y) {
             return defaultTaxonService.replace(x, y);
             return defaultService.replace(x, y);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> find(Set<UUID> uuidSet) {
             return defaultTaxonService.find(uuidSet);
             return defaultService.find(uuidSet);
+        }
         /**
-...
          */
         @Override
         public Pager<IdentifiableSource> getSources(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
             return defaultTaxonService.getSources(t, pageSize, pageNumber, propertyPaths);
             return defaultService.getSources(t, pageSize, pageNumber, propertyPaths);
+        }
         /**
-...
         @Deprecated
         @Override
         public List<Taxon> getRootTaxa(Reference sec, CdmFetch cdmFetch, boolean onlyWithChildren) {
             return defaultTaxonService.getRootTaxa(sec, cdmFetch, onlyWithChildren);
             return defaultService.getRootTaxa(sec, cdmFetch, onlyWithChildren);
+        }
         /**
-...
          */
         @Override
         public TaxonBase find(UUID uuid) {
             return defaultTaxonService.find(uuid);
             return defaultService.find(uuid);
+        }
         /**
-...
         @Deprecated
         @Override
         public List<Taxon> getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren, boolean withMisapplications, List<String> propertyPaths) {
             return defaultTaxonService.getRootTaxa(rank, sec, onlyWithChildren, withMisapplications, propertyPaths);
             return defaultService.getRootTaxa(rank, sec, onlyWithChildren, withMisapplications, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public TaxonBase find(int id) {
             return defaultTaxonService.find(id);
             return defaultService.find(id);
+        }
         /**
-...
          */
         @Override
         public Pager<Rights> getRights(TaxonBase t, Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
             return defaultTaxonService.getRights(t, pageSize, pageNumber, propertyPaths);
             return defaultService.getRights(t, pageSize, pageNumber, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public int countMarkers(Class<? extends TaxonBase> clazz, Boolean technical) {
             return defaultTaxonService.countMarkers(clazz, technical);
             return defaultService.countMarkers(clazz, technical);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> findById(Set<Integer> idSet) {
             return defaultTaxonService.findById(idSet);
             return defaultService.findById(idSet);
+        }
         /**
-...
          */
         @Override
         public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) {
             return defaultTaxonService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
             return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace);
+        }
         /**
-...
          */
         @Override
         public Session getSession() {
             return defaultTaxonService.getSession();
             return defaultService.getSession();
+        }
         /**
-...
          */
         @Override
         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCache() {
             return defaultTaxonService.getUuidAndTitleCache();
             return defaultService.getUuidAndTitleCache();
+        }
         /**
-...
          */
         @Override
         public List<Object[]> group(Class<? extends TaxonBase> clazz, Integer limit, Integer start, List<Grouping> groups, List<String> propertyPaths) {
             return defaultTaxonService.group(clazz, limit, start, groups, propertyPaths);
             return defaultService.group(clazz, limit, start, groups, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<RelationshipBase> getAllRelationships(int limit, int start) {
             return defaultTaxonService.getAllRelationships(limit, start);
             return defaultService.getAllRelationships(limit, start);
+        }
         /**
-...
          */
         @Override
         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) {
             return defaultTaxonService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
         @Deprecated
         @Override
         public OrderedTermVocabulary<TaxonRelationshipType> getTaxonRelationshipTypeVocabulary() {
             return defaultTaxonService.getTaxonRelationshipTypeVocabulary();
             return defaultService.getTaxonRelationshipTypeVocabulary();
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> searchTaxaByName(String name, Reference sec) {
             return defaultTaxonService.searchTaxaByName(name, sec);
             return defaultService.searchTaxaByName(name, sec);
+        }
         /**
-...
          */
         @Override
         public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon) {
             defaultTaxonService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon);
             defaultService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon);
+        }
         /**
-...
          */
         @Override
         public <S extends TaxonBase> List<S> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.list(type, limit, start, orderHints, propertyPaths);
             return defaultService.list(type, limit, start, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonBase> findByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
             return defaultTaxonService.findByTitle(configurator);
             return defaultService.findByTitle(configurator);
+        }
         /**
-...
          */
         @Override
         public Taxon changeSynonymToAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon, boolean deleteSynonym, boolean copyCitationInfo, Reference citation, String microCitation) throws HomotypicalGroupChangeException {
             return defaultTaxonService.changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, deleteSynonym, copyCitationInfo, citation, microCitation);
             return defaultService.changeSynonymToAcceptedTaxon(synonym, acceptedTaxon, deleteSynonym, copyCitationInfo, citation, microCitation);
+        }
         /**
-...
          */
         @Override
         public Integer countByTitle(Class<? extends TaxonBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria) {
             return defaultTaxonService.countByTitle(clazz, queryString, matchmode, criteria);
             return defaultService.countByTitle(clazz, queryString, matchmode, criteria);
+        }
         /**
-...
          */
         @Override
         public TaxonBase load(UUID uuid) {
             return defaultTaxonService.load(uuid);
             return defaultService.load(uuid);
+        }
         /**
-...
          */
         @Override
         public TaxonBase load(UUID uuid, List<String> propertyPaths) {
             return defaultTaxonService.load(uuid, propertyPaths);
             return defaultService.load(uuid, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Integer countByTitle(IIdentifiableEntityServiceConfigurator<TaxonBase> configurator) {
             return defaultTaxonService.countByTitle(configurator);
             return defaultService.countByTitle(configurator);
+        }
         /**
-...
          */
         @Override
         public TaxonBase merge(TaxonBase transientObject) {
             return defaultTaxonService.merge(transientObject);
             return defaultService.merge(transientObject);
+        }
         /**
-...
          */
         @Override
         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) {
             return defaultTaxonService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public  <S extends TaxonBase> Pager<S> page(Class<S> type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public UUID refresh(TaxonBase persistentObject) {
             return defaultTaxonService.refresh(persistentObject);
             return defaultService.refresh(persistentObject);
+        }
         /**
-...
          */
         @Override
         public Taxon changeSynonymToRelatedTaxon(Synonym synonym, Taxon toTaxon, TaxonRelationshipType taxonRelationshipType, Reference reference, String microReference) {
             return defaultTaxonService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference);
             return defaultService.changeSynonymToRelatedTaxon(synonym, toTaxon, taxonRelationshipType, reference, microReference);
+        }
         /**
-...
          */
         @Override
         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) {
             return defaultTaxonService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> rows(String tableName, int limit, int start) {
             return defaultTaxonService.rows(tableName, limit, start);
             return defaultService.rows(tableName, limit, start);
+        }
         /**
-...
          */
         @Override
         public long deleteSynonymRelationships(Synonym syn, Taxon taxon) {
             return defaultTaxonService.deleteSynonymRelationships(syn, taxon);
             return defaultService.deleteSynonymRelationships(syn, taxon);
+        }
         /**
-...
          */
         @Override
         public void changeHomotypicalGroupOfSynonym(Synonym synonym, HomotypicalGroup newHomotypicalGroup, Taxon targetTaxon, boolean removeFromOtherTaxa, boolean setBasionymRelationIfApplicable) {
             defaultTaxonService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable);
             defaultService.changeHomotypicalGroupOfSynonym(synonym, newHomotypicalGroup, targetTaxon, removeFromOtherTaxa, setBasionymRelationIfApplicable);
+        }
         /**
-...
          */
         @Override
         public UUID update(TaxonBase transientObject) {
             return defaultTaxonService.update(transientObject);
             return defaultService.update(transientObject);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> list(TaxonBase example, Set<String> includeProperties, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
             return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public SynonymRelationship moveSynonymToAnotherTaxon(SynonymRelationship oldSynonymRelation, Taxon newTaxon, boolean moveHomotypicGroup, SynonymRelationshipType newSynonymRelationshipType, Reference newReference, String newReferenceDetail, boolean keepReference) throws HomotypicalGroupChangeException {
             return defaultTaxonService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);
             return defaultService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxon, moveHomotypicGroup, newSynonymRelationshipType, newReference, newReferenceDetail, keepReference);
+        }
         /**
-...
          */
         @Override
         public int deduplicate(Class<? extends TaxonBase> clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) {
             return defaultTaxonService.deduplicate(clazz, matchStrategy, mergeStrategy);
             return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonBase> findTitleCache(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, MatchMode matchMode) {
             return defaultTaxonService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
             return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode);
+        }
         /**
-...
          */
         @Override
         public List<TaxonRelationship> listToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.listToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonRelationship> pageToTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.pageToTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<TaxonRelationship> listFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.listFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonRelationship> pageFromTaxonRelationships(Taxon taxon, TaxonRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.pageFromTaxonRelationships(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Set<Taxon> listRelatedTaxa(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Integer maxDepth, Integer limit, Integer start, List<String> propertyPaths) {
             return defaultTaxonService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths);
             return defaultService.listRelatedTaxa(taxon, includeRelationships, maxDepth, limit, start, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<Classification> listClassifications(TaxonBase taxonBase, Integer limit, Integer start, List<String> propertyPaths) {
             return defaultTaxonService.listClassifications(taxonBase, limit, start, propertyPaths);
             return defaultService.listClassifications(taxonBase, limit, start, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<SynonymRelationship> getSynonyms(Synonym synonym, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.getSynonyms(synonym, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<SynonymRelationship> getSynonyms(Taxon taxon, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.getSynonyms(taxon, type, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<Synonym> getHomotypicSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
             return defaultTaxonService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths);
             return defaultService.getHomotypicSynonymsByHomotypicGroup(taxon, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public List<List<Synonym>> getHeterotypicSynonymyGroups(Taxon taxon, List<String> propertyPaths) {
             return defaultTaxonService.getHeterotypicSynonymyGroups(taxon, propertyPaths);
             return defaultService.getHeterotypicSynonymyGroups(taxon, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonBase> search(Class<? extends TaxonBase> clazz, String queryString, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public Pager<TaxonBase> findTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber) {
             return defaultTaxonService.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
             return defaultService.findTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> listTaxaByName(Class<? extends TaxonBase> clazz, String uninomial, String infragenericEpithet, String specificEpithet, String infraspecificEpithet, Rank rank, Integer pageSize, Integer pageNumber) {
             return defaultTaxonService.listTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
             return defaultService.listTaxaByName(clazz, uninomial, infragenericEpithet, specificEpithet, infraspecificEpithet, rank, pageSize, pageNumber);
+        }
         /**
-...
          */
         @Override
         public Pager<IdentifiableEntity> findTaxaAndNames(IFindTaxaAndNamesConfigurator configurator) {
             return defaultTaxonService.findTaxaAndNames(configurator);
             return defaultService.findTaxaAndNames(configurator);
+        }
         /**
-...
         @Deprecated
         @Override
         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 {
             return defaultTaxonService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findByEverythingFullText(queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         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 {
             return defaultTaxonService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findByFullText(clazz, queryString, classification, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+        }
-...
                 List<PresenceAbsenceTerm> statusFilter, Classification classification, Integer pageSize,
                 Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException,
                 ParseException {
             return defaultTaxonService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
+        }
-...
                 Set<PresenceAbsenceTerm> distributionStatus, List<Language> languages, boolean highlightFragments,
                 Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths)
                 throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
             return defaultTaxonService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findTaxaAndNamesByFullText(searchModes, queryString, classification, namedAreas, distributionStatus, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
          */
         @Override
         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 {
             return defaultTaxonService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.findByDescriptionElementFullText(clazz, queryString, classification, features, languages, highlightFragments, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /**
-...
         @Deprecated
         @Override
         public List<MediaRepresentation> getAllMedia(Taxon taxon, int size, int height, int widthOrDuration, String[] mimeTypes) {
             return defaultTaxonService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes);
             return defaultService.getAllMedia(taxon, size, height, widthOrDuration, mimeTypes);
+        }
         /**
-...
         @Deprecated
         @Override
         public List<Media> listTaxonDescriptionMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, boolean limitToGalleries, List<String> propertyPath) {
             return defaultTaxonService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath);
             return defaultService.listTaxonDescriptionMedia(taxon, includeRelationships, limitToGalleries, propertyPath);
+        }
         /**
-...
          */
         @Override
         public List<Media> listMedia(Taxon taxon, Set<TaxonRelationshipEdge> includeRelationships, Boolean limitToGalleries, Boolean includeTaxonDescriptions, Boolean includeOccurrences, Boolean includeTaxonNameDescriptions, List<String> propertyPath) {
             return defaultTaxonService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath);
             return defaultService.listMedia(taxon, includeRelationships, limitToGalleries, includeTaxonDescriptions, includeOccurrences, includeTaxonNameDescriptions, propertyPath);
+        }
         /**
-...
          */
         @Override
         public List<TaxonBase> findTaxaByID(Set<Integer> listOfIDs) {
             return defaultTaxonService.findTaxaByID(listOfIDs);
             return defaultService.findTaxaByID(listOfIDs);
+        }
         /**
-...
          */
         @Override
         public TaxonBase findTaxonByUuid(UUID uuid, List<String> propertyPaths) {
             return defaultTaxonService.findTaxonByUuid(uuid, propertyPaths);
             return defaultService.findTaxonByUuid(uuid, propertyPaths);
+        }
         /**
-...
          */
         @Override
         public int countAllRelationships() {
             return defaultTaxonService.countAllRelationships();
             return defaultService.countAllRelationships();
+        }
         /**
-...
          */
         @Override
         public List<TaxonNameBase> findIdenticalTaxonNames(List<String> propertyPath) {
             return defaultTaxonService.findIdenticalTaxonNames(propertyPath);
             return defaultService.findIdenticalTaxonNames(propertyPath);
+        }
         /**
-...
          */
         @Override
         public List<TaxonNameBase> findIdenticalTaxonNameIds(List<String> propertyPath) {
             return defaultTaxonService.findIdenticalTaxonNameIds(propertyPath);
             return defaultService.findIdenticalTaxonNameIds(propertyPath);
+        }
         /**
-...
          */
         @Override
         public String getPhylumName(TaxonNameBase name) {
             return defaultTaxonService.getPhylumName(name);
             return defaultService.getPhylumName(name);
+        }
         /**
-...
          */
         @Override
         public long deleteSynonymRelationships(Synonym syn) {
             return defaultTaxonService.deleteSynonymRelationships(syn);
             return defaultService.deleteSynonymRelationships(syn);
+        }
         /**
-...
          */
         @Override
         public List<SynonymRelationship> listSynonymRelationships(TaxonBase taxonBase, SynonymRelationshipType type, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths, Direction direction) {
             return defaultTaxonService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction);
             return defaultService.listSynonymRelationships(taxonBase, type, pageSize, pageNumber, orderHints, propertyPaths, direction);
+        }
         /**
-...
          */
         @Override
         public Taxon findBestMatchingTaxon(String taxonName) {
             return defaultTaxonService.findBestMatchingTaxon(taxonName);
             return defaultService.findBestMatchingTaxon(taxonName);
+        }
         /**
-...
          */
         @Override
         public Taxon findBestMatchingTaxon(MatchingTaxonConfigurator config) {
             return defaultTaxonService.findBestMatchingTaxon(config);
             return defaultService.findBestMatchingTaxon(config);
+        }
         /**
-...
          */
         @Override
         public Synonym findBestMatchingSynonym(String taxonName) {
             return defaultTaxonService.findBestMatchingSynonym(taxonName);
             return defaultService.findBestMatchingSynonym(taxonName);
+        }
         /**
-...
          */
         @Override
         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheTaxon() {
             return defaultTaxonService.getUuidAndTitleCacheTaxon();
             return defaultService.getUuidAndTitleCacheTaxon();
+        }
         /**
-...
          */
         @Override
         public List<UuidAndTitleCache<TaxonBase>> getUuidAndTitleCacheSynonym() {
             return defaultTaxonService.getUuidAndTitleCacheSynonym();
             return defaultService.getUuidAndTitleCacheSynonym();
+        }
         /**
-...
          */
         @Override
         public List<UuidAndTitleCache<IdentifiableEntity>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator configurator) {
             return defaultTaxonService.findTaxaAndNamesForEditor(configurator);
             return defaultService.findTaxaAndNamesForEditor(configurator);
+        }
         /**
-...
          */
         @Override
         public List<Synonym> createInferredSynonyms(Taxon taxon, Classification tree, SynonymRelationshipType type, boolean doWithMisappliedNames) {
             return defaultTaxonService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames);
             return defaultService.createInferredSynonyms(taxon, tree, type, doWithMisappliedNames);
+        }
         /**
-...
          */
         @Override
         public List<Synonym> createAllInferredSynonyms(Taxon taxon, Classification tree, boolean doWithMisappliedNames) {
             return defaultTaxonService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames);
             return defaultService.createAllInferredSynonyms(taxon, tree, doWithMisappliedNames);
+        }
         @Override
         public DeleteResult deleteSynonym(Synonym arg0, SynonymDeletionConfigurator arg1) {
             return defaultTaxonService.deleteSynonym(arg0, arg1);
             return defaultService.deleteSynonym(arg0, arg1);
+        }
         @Override
         public DeleteResult deleteSynonym(Synonym arg0, Taxon arg1, SynonymDeletionConfigurator arg2) {
             return defaultTaxonService.deleteSynonym(arg0, arg1, arg2);
             return defaultService.deleteSynonym(arg0, arg1, arg2);
+        }
         @Override
         public DeleteResult deleteTaxon(Taxon arg0, TaxonDeletionConfigurator arg1, Classification arg2) {
             return defaultTaxonService.deleteTaxon(arg0, arg1, arg2);
             return defaultService.deleteTaxon(arg0, arg1, arg2);
+        }
         @Override
         public List<List<Synonym>> getSynonymsByHomotypicGroup(Taxon taxon, List<String> propertyPaths) {
             return defaultTaxonService.getSynonymsByHomotypicGroup(taxon, propertyPaths);
             return defaultService.getSynonymsByHomotypicGroup(taxon, propertyPaths);
+        }
     	@Override
-...
     			SynonymRelationshipType synonymRelationshipType)
     			throws DataChangeNoRollbackException {
     		return defaultTaxonService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
     		return defaultService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
+    	}
         /* (non-Javadoc)
-...
         @Override
         public Pager<Taxon> pageAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
                 Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.pageAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.pageAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
+        }
         /* (non-Javadoc)
-...
         @Override
         public List<Taxon> listAcceptedTaxaFor(UUID synonymUuid, UUID classificationUuid, Integer pageSize,
                 Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) {
             return defaultTaxonService.listAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
             return defaultService.listAcceptedTaxaFor(synonymUuid, classificationUuid, pageSize, pageNumber, orderHints, propertyPaths);
+        }
     	@Override
-...
     	@Override
     	public TaxonBase findWithoutFlush(UUID uuid) {
     		return defaultTaxonService.findWithoutFlush(uuid);
     		return defaultService.findWithoutFlush(uuid);
+    	}
         /* (non-Javadoc)
-...
          */
         @Override
         public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config) {
             return defaultTaxonService.findTaxaByName(config);
             return defaultService.findTaxaByName(config);
+        }
     	@Override
     	public <S extends TaxonBase> List<S> listByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths){
     		return defaultService.listByIdentifier(clazz, identifier, identifierType, matchmode, pageSize, pageNumber, orderHints, propertyPaths);
+    	}

Also available in: Unified diff

Project

General

Profile

EDIT

Revision 7c1862cd

Added by Andreas Müller over 9 years ago