// $Id$
/**
-* Copyright (C) 2013 EDIT
-* European Distributed Institute of Taxonomy
-* http://www.e-taxonomy.eu
-*
-* The contents of this file are subject to the Mozilla Public License Version 1.1
-* See LICENSE.TXT at the top of this package for the full license terms.
-*/
+ * Copyright (C) 2013 EDIT
+ * European Distributed Institute of Taxonomy
+ * http://www.e-taxonomy.eu
+ *
+ * The contents of this file are subject to the Mozilla Public License Version 1.1
+ * See LICENSE.TXT at the top of this package for the full license terms.
+ */
package eu.etaxonomy.taxeditor.editor.view.dataimport.transientServices;
import java.io.IOException;
import java.util.UUID;
import org.apache.lucene.index.CorruptIndexException;
-import org.apache.lucene.queryParser.ParseException;
+import org.apache.lucene.queryparser.classic.ParseException;
import org.hibernate.LockOptions;
import org.hibernate.Session;
import org.hibernate.criterion.Criterion;
import eu.etaxonomy.cdm.api.service.DeleteResult;
import eu.etaxonomy.cdm.api.service.ITaxonService;
import eu.etaxonomy.cdm.api.service.TaxaAndNamesSearchMode;
+import eu.etaxonomy.cdm.api.service.UpdateResult;
import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase;
import eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator;
import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator;
import eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator;
import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;
import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;
+import eu.etaxonomy.cdm.api.service.dto.FindByIdentifierDTO;
import eu.etaxonomy.cdm.api.service.dto.IncludedTaxaDTO;
import eu.etaxonomy.cdm.api.service.exception.DataChangeNoRollbackException;
import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;
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;
import eu.etaxonomy.cdm.model.common.OrderedTermVocabulary;
import eu.etaxonomy.cdm.model.common.RelationshipBase;
import eu.etaxonomy.cdm.model.common.RelationshipBase.Direction;
-import eu.etaxonomy.cdm.model.common.UuidAndTitleCache;
import eu.etaxonomy.cdm.model.description.DescriptionElementBase;
import eu.etaxonomy.cdm.model.description.Feature;
-import eu.etaxonomy.cdm.model.description.PresenceAbsenceTermBase;
+import eu.etaxonomy.cdm.model.description.PresenceAbsenceTerm;
import eu.etaxonomy.cdm.model.location.NamedArea;
import eu.etaxonomy.cdm.model.media.Media;
import eu.etaxonomy.cdm.model.media.MediaRepresentation;
import eu.etaxonomy.cdm.model.taxon.SynonymRelationshipType;
import eu.etaxonomy.cdm.model.taxon.Taxon;
import eu.etaxonomy.cdm.model.taxon.TaxonBase;
+import eu.etaxonomy.cdm.model.taxon.TaxonNode;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationship;
import eu.etaxonomy.cdm.model.taxon.TaxonRelationshipType;
import eu.etaxonomy.cdm.model.view.AuditEvent;
import eu.etaxonomy.cdm.model.view.AuditEventRecord;
import eu.etaxonomy.cdm.persistence.dao.common.AuditEventSort;
+import eu.etaxonomy.cdm.persistence.dto.MergeResult;
+import eu.etaxonomy.cdm.persistence.dto.UuidAndTitleCache;
import eu.etaxonomy.cdm.persistence.fetch.CdmFetch;
import eu.etaxonomy.cdm.persistence.query.Grouping;
import eu.etaxonomy.cdm.persistence.query.MatchMode;
*/
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);
}
+
/**
- * @param synonym
- * @param acceptedTaxon
- * @see eu.etaxonomy.cdm.api.service.ITaxonService#swapSynonymAndAcceptedTaxon(eu.etaxonomy.cdm.model.taxon.Synonym, eu.etaxonomy.cdm.model.taxon.Taxon)
+ * {@inheritDoc}
*/
@Override
- public void swapSynonymAndAcceptedTaxon(Synonym synonym, Taxon acceptedTaxon) {
- defaultTaxonService.swapSynonymAndAcceptedTaxon(synonym, acceptedTaxon);
+ public UpdateResult swapSynonymAndAcceptedTaxon(Synonym arg0, Taxon arg1) {
+ return defaultService.swapSynonymAndAcceptedTaxon(arg0, arg1);
+
}
/**
*/
@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);
}
/**
* @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase)
*/
@Override
- public UUID save(TaxonBase newInstance) {
+ public TaxonBase save(TaxonBase newInstance) {
return null;
}
*/
@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);
}
- /**
- * @param areaFilter
- * @param statusFilter
- * @param classification
- * @param pageSize
- * @param pageNumber
- * @param orderHints
- * @param propertyPaths
- * @return
- * @throws IOException
- * @throws ParseException
+
+ /* (non-Javadoc)
* @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)
*/
@Override
- public Pager<SearchResult<TaxonBase>> findByDistribution(List<NamedArea> areaFilter, List<PresenceAbsenceTermBase<?>> 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);
+ public Pager<SearchResult<TaxonBase>> findByDistribution(List<NamedArea> areaFilter,
+ List<PresenceAbsenceTerm> statusFilter, Classification classification, Integer pageSize,
+ Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths) throws IOException,
+ ParseException {
+ return defaultService.findByDistribution(areaFilter, statusFilter, classification, pageSize, pageNumber, orderHints, propertyPaths);
}
- /**
- * @param searchModes
- * @param queryString
- * @param classification
- * @param namedAreas
- * @param distributionStatus
- * @param languages
- * @param highlightFragments
- * @param pageSize
- * @param pageNumber
- * @param orderHints
- * @param propertyPaths
- * @return
- * @throws CorruptIndexException
- * @throws IOException
- * @throws ParseException
- * @throws LuceneMultiSearchException
+
+ /* (non-Javadoc)
* @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)
*/
@Override
- public Pager<SearchResult<TaxonBase>> findTaxaAndNamesByFullText(EnumSet<TaxaAndNamesSearchMode> searchModes, String queryString, Classification classification, Set<NamedArea> namedAreas, Set<PresenceAbsenceTermBase<?>> 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);
+ public Pager<SearchResult<TaxonBase>> findTaxaAndNamesByFullText(EnumSet<TaxaAndNamesSearchMode> searchModes,
+ String queryString, Classification classification, Set<NamedArea> namedAreas,
+ Set<PresenceAbsenceTerm> distributionStatus, List<Language> languages, boolean highlightFragments,
+ Integer pageSize, Integer pageNumber, List<OrderHint> orderHints, List<String> propertyPaths)
+ throws CorruptIndexException, IOException, ParseException, LuceneMultiSearchException {
+ 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();
}
/**
* @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaAndNamesForEditor(eu.etaxonomy.cdm.api.service.config.IFindTaxaAndNamesConfigurator)
*/
@Override
- public List<UuidAndTitleCache<TaxonBase>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator configurator) {
- return defaultTaxonService.findTaxaAndNamesForEditor(configurator);
+ public List<UuidAndTitleCache<IdentifiableEntity>> findTaxaAndNamesForEditor(IFindTaxaAndNamesConfigurator 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);
- }
-
- @Override
- public DeleteResult deleteTaxon(Taxon arg0, TaxonDeletionConfigurator arg1, Classification arg2) {
- return defaultTaxonService.deleteTaxon(arg0, arg1, arg2);
+ return defaultService.deleteSynonym(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
- public Synonym changeRelatedTaxonToSynonym(Taxon fromTaxon, Taxon toTaxon,
- TaxonRelationshipType oldRelationshipType,
- SynonymRelationshipType synonymRelationshipType)
- throws DataChangeNoRollbackException {
+ @Override
+ public Synonym changeRelatedTaxonToSynonym(Taxon fromTaxon, Taxon toTaxon,
+ TaxonRelationshipType oldRelationshipType,
+ SynonymRelationshipType synonymRelationshipType)
+ throws DataChangeNoRollbackException {
- return defaultTaxonService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
- }
+ return defaultService.changeRelatedTaxonToSynonym(fromTaxon, toTaxon, oldRelationshipType, synonymRelationshipType);
+ }
/* (non-Javadoc)
* @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)
@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
- public List<String> isDeletable(TaxonBase object,
- DeleteConfiguratorBase config) {
- // TODO Auto-generated method stub
- return null;
- }
+ @Override
+ public DeleteResult isDeletable(TaxonBase object,
+ DeleteConfiguratorBase config) {
+ // TODO Auto-generated method stub
+ return null;
+ }
- @Override
- public IncludedTaxaDTO listIncludedTaxa(UUID taxonUuid,
- IncludedTaxonConfiguration configuration) {
- // TODO Auto-generated method stub
- return null;
- }
+ @Override
+ public IncludedTaxaDTO listIncludedTaxa(UUID taxonUuid,
+ IncludedTaxonConfiguration configuration) {
+ // TODO Auto-generated method stub
+ return null;
+ }
- @Override
- public TaxonBase findWithoutFlush(UUID uuid) {
- return defaultTaxonService.findWithoutFlush(uuid);
- }
+ @Override
+ public TaxonBase findWithoutFlush(UUID uuid) {
+ return defaultService.findWithoutFlush(uuid);
+ }
/* (non-Javadoc)
* @see eu.etaxonomy.cdm.api.service.ITaxonService#findTaxaByName(eu.etaxonomy.cdm.api.service.config.MatchingTaxonConfigurator)
*/
@Override
public List<TaxonBase> findTaxaByName(MatchingTaxonConfigurator config) {
- return defaultTaxonService.findTaxaByName(config);
+ return defaultService.findTaxaByName(config);
+ }
+
+ @Override
+ public <S extends TaxonBase> Pager<FindByIdentifierDTO<S>> findByIdentifier(Class<S> clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeEntity, Integer pageSize, Integer pageNumber, List<String> propertyPaths){
+ return defaultService.findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
+ }
+
+ /* (non-Javadoc)
+ * @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)
+ */
+ @Override
+ public <S extends TaxonBase> Pager<FindByIdentifierDTO<S>> findByIdentifier(Class<S> clazz, String identifier,
+ DefinedTerm identifierType, TaxonNode subtreeFilter, MatchMode matchmode, boolean includeEntity,
+ Integer pageSize, Integer pageNumber, List<String> propertyPaths) {
+ return defaultService.findByIdentifier(clazz, identifier, identifierType, subtreeFilter, matchmode, includeEntity, pageSize, pageNumber, propertyPaths);
+ }
+
+
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(java.util.UUID, java.util.UUID, eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator)
+ */
+ @Override
+ public DeleteResult deleteSynonym(UUID synonymUuid, UUID taxonUuid, SynonymDeletionConfigurator config) {
+ return defaultService.deleteSynonym(synonymUuid, taxonUuid, config);
+ }
+
+
+ /**
+ * {@inheritDoc}
+
+ */
+ @Override
+ public UpdateResult swapSynonymAndAcceptedTaxon(UUID synonymUUid, UUID acceptedTaxonUuid) {
+ return defaultService.swapSynonymAndAcceptedTaxon(synonymUUid, acceptedTaxonUuid);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteTaxon(java.util.UUID, eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator, java.util.UUID)
+ */
+ @Override
+ public DeleteResult deleteTaxon(UUID taxonUuid, TaxonDeletionConfigurator config, UUID classificationUuid) {
+ return defaultService.deleteTaxon(taxonUuid, config, classificationUuid);
}
+ @Override
+ public UpdateResult moveFactualDateToAnotherTaxon(UUID arg0, UUID arg1) {
+ return defaultService.moveFactualDateToAnotherTaxon(arg0, arg1);
+ }
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public UpdateResult moveSynonymToAnotherTaxon(
+ SynonymRelationship oldSynonymRelation, UUID newTaxonUUID,
+ boolean moveHomotypicGroup,
+ SynonymRelationshipType newSynonymRelationshipType,
+ Reference reference, String referenceDetail, boolean keepReference)
+ throws HomotypicalGroupChangeException {
+
+ return defaultService.moveSynonymToAnotherTaxon(oldSynonymRelation, newTaxonUUID, moveHomotypicGroup, newSynonymRelationshipType, reference, referenceDetail, keepReference);
+ }
+
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.UUID)
+ */
+ @Override
+ public DeleteResult delete(UUID uuid) {
+ return defaultService.delete(uuid);
+
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.Collection)
+ */
+ @Override
+ public DeleteResult delete(Collection<UUID> arg0) {
+ return defaultService.delete(arg0);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List)
+ */
+ @Override
+ public List<TaxonBase> merge(List<TaxonBase> arg0) {
+ return defaultService.merge(arg0);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.ITaxonService#deleteSynonym(java.util.UUID, eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator)
+ */
+ @Override
+ public DeleteResult deleteSynonym(UUID arg0, SynonymDeletionConfigurator arg1) {
+ return defaultService.deleteSynonym(arg0, arg1);
+ }
+
+ /* (non-Javadoc)
+ * @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)
+ */
+ @Override
+ public UpdateResult changeSynonymToRelatedTaxon(UUID arg0, UUID arg1, TaxonRelationshipType arg2, Reference arg3,
+ String arg4) {
+ return defaultService.changeSynonymToRelatedTaxon(arg0, arg1, arg2, arg3, arg4);
+ }
+
+ /* (non-Javadoc)
+ * @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)
+ */
+ @Override
+ public UpdateResult changeRelatedTaxonToSynonym(UUID arg0, UUID arg1, TaxonRelationshipType arg2,
+ SynonymRelationshipType arg3) throws DataChangeNoRollbackException {
+ return defaultService.changeRelatedTaxonToSynonym(arg0, arg1, arg2, arg3);
+
+ }
+
+ /* (non-Javadoc)
+ * @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)
+ */
+ @Override
+ public UpdateResult changeSynonymToAcceptedTaxon(UUID arg0, UUID arg1, UUID arg2, boolean arg3, boolean arg4,
+ Reference arg5, String arg6) throws HomotypicalGroupChangeException {
+ return defaultService.changeSynonymToAcceptedTaxon(arg0, arg1, arg2, arg3, arg4, arg5, arg6);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean)
+ */
+ @Override
+ public List<MergeResult<TaxonBase>> merge(List<TaxonBase> arg0, boolean arg1) {
+ return defaultService.merge(arg0, arg1);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase, boolean)
+ */
+ @Override
+ public MergeResult<TaxonBase> merge(TaxonBase arg0, boolean arg1) {
+ return defaultService.merge(arg0, arg1);
+ }
+
+ /* (non-Javadoc)
+ * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID)
+ */
+ @Override
+ public TaxonBase loadWithUpdate(UUID arg0) {
+ return defaultService.loadWithUpdate(arg0);
+ }
+
+ /**
+ * {@inheritDoc}
+ */
+ @Override
+ public List<TaxonBase> load(List<UUID> arg0, List<String> arg1) {
+ return defaultService.load(arg0, arg1);
+ }
}
BGBM BDI Projects / taxeditor.git / blobdiff