From e8f969654647b5dea4b51446838108c0e812ed95 Mon Sep 17 00:00:00 2001 From: =?utf8?q?Andreas=20M=C3=BCller?= Date: Thu, 30 Jun 2016 16:34:19 +0200 Subject: [PATCH] Fix compile errors in transient services for loadByIds --- .../TransientAgentService.java | 5 +- .../TransientClassificationService.java | 5 +- .../TransientClassificationService.java.orig | 1027 +++++++++++++++++ .../TransientCollectionService.java | 5 +- .../TransientDescriptionService.java | 5 +- .../TransientNameService.java | 6 +- .../TransientOccurenceService.java | 5 +- .../TransientReferenceService.java | 5 +- .../TransientTaxonService.java | 5 +- .../TransientTermService.java | 5 +- 10 files changed, 1046 insertions(+), 27 deletions(-) create mode 100644 eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java.orig diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientAgentService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientAgentService.java index 2fa22c3d8..cbced545a 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientAgentService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientAgentService.java @@ -847,10 +847,9 @@ public class TransientAgentService implements IAgentService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java index c06ab0872..9176c86ad 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java @@ -1018,10 +1018,9 @@ public class TransientClassificationService implements IClassificationService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } @Override diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java.orig b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java.orig new file mode 100644 index 000000000..60c7dc299 --- /dev/null +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientClassificationService.java.orig @@ -0,0 +1,1027 @@ +// $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. +*/ +package eu.etaxonomy.taxeditor.editor.view.dataimport.transientServices; + +import java.util.Collection; +import java.util.List; +import java.util.Map; +import java.util.Set; +import java.util.UUID; + +import org.hibernate.LockOptions; +import org.hibernate.Session; +import org.hibernate.criterion.Criterion; +import org.hibernate.envers.query.criteria.AuditCriterion; + +import eu.etaxonomy.cdm.api.service.DeleteResult; +import eu.etaxonomy.cdm.api.service.IClassificationService; +import eu.etaxonomy.cdm.api.service.UpdateResult; +import eu.etaxonomy.cdm.api.service.config.CreateHierarchyForClassificationConfigurator; +import eu.etaxonomy.cdm.api.service.config.DeleteConfiguratorBase; +import eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator; +import eu.etaxonomy.cdm.api.service.dto.FindByIdentifierDTO; +import eu.etaxonomy.cdm.api.service.pager.Pager; +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.IdentifiableSource; +import eu.etaxonomy.cdm.model.common.LSID; +import eu.etaxonomy.cdm.model.common.Marker; +import eu.etaxonomy.cdm.model.common.MarkerType; +import eu.etaxonomy.cdm.model.media.MediaRepresentation; +import eu.etaxonomy.cdm.model.media.Rights; +import eu.etaxonomy.cdm.model.name.Rank; +import eu.etaxonomy.cdm.model.taxon.Classification; +import eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode; +import eu.etaxonomy.cdm.model.taxon.Taxon; +import eu.etaxonomy.cdm.model.taxon.TaxonNode; +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.query.Grouping; +import eu.etaxonomy.cdm.persistence.query.MatchMode; +import eu.etaxonomy.cdm.persistence.query.OrderHint; +import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy; +import eu.etaxonomy.cdm.strategy.match.IMatchStrategy; +import eu.etaxonomy.cdm.strategy.merge.IMergeStrategy; + +/** + * @author pplitzner + * @date 27.09.2013 + * + */ +public class TransientClassificationService implements IClassificationService { + + private final IClassificationService defaultService; + + /** + * @param defaultClassificationService + */ + public TransientClassificationService(IClassificationService defaultClassificationService) { + this.defaultService = defaultClassificationService; + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param sort + * @param propertyPaths + * @return + * @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) + */ + @Override + public Pager> pageAuditEvents(Classification t, Integer pageSize, Integer pageNumber, AuditEventSort sort, List propertyPaths) { + return defaultService.pageAuditEvents(t, pageSize, pageNumber, sort, propertyPaths); + } + + /** + * @param annotatedObj + * @param status + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public Pager getAnnotations(Classification annotatedObj, MarkerType status, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.getAnnotations(annotatedObj, status, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeByUuid(java.util.UUID) + */ + @Override + public TaxonNode getTaxonNodeByUuid(UUID uuid) { + return defaultService.getTaxonNodeByUuid(uuid); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTreeNodeByUuid(java.util.UUID) + */ + @Override + public ITaxonTreeNode getTreeNodeByUuid(UUID uuid) { + return defaultService.getTreeNodeByUuid(uuid); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IService#clear() + */ + @Override + public void clear() { + defaultService.clear(); + } + + /** + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#listClassifications(java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List listClassifications(Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultService.listClassifications(limit, start, orderHints, propertyPaths); + } + + /** + * @param t + * @param lockMode + * @see eu.etaxonomy.cdm.api.service.IService#lock(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode) + */ + @Override + public void lock(Classification t, LockOptions lockOptions) { + defaultService.lock(t, lockOptions); + } + + /** + * @param t + * @param lockMode + * @param propertyPaths + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase, org.hibernate.LockMode, java.util.List) + */ + @Override + public void refresh(Classification t, LockOptions lockOptions, List propertyPaths) { + defaultService.refresh(t, lockOptions, propertyPaths); + } + + /** + * @param taxon + * @param classificationUuid + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNodeByTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, java.util.UUID, java.util.List) + */ + @Deprecated + @Override + public TaxonNode loadTaxonNodeByTaxon(Taxon taxon, UUID classificationUuid, List propertyPaths) { + return defaultService.loadTaxonNodeByTaxon(taxon, classificationUuid, propertyPaths); + } + + /** + * + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#updateTitleCache() + */ + @Override + public void updateTitleCache() { + defaultService.updateTitleCache(); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getNextAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getNextAuditEvent(Classification t) { + return defaultService.getNextAuditEvent(t); + } + + /** + * @param annotatableEntity + * @param technical + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public Pager getMarkers(Classification annotatableEntity, Boolean technical, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.getMarkers(annotatableEntity, technical, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param stepSize + * @param cacheStrategy + * @param monitor + * @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) + */ + @Override + public void updateTitleCache(Class clazz, Integer stepSize, IIdentifiableEntityCacheStrategy cacheStrategy, IProgressMonitor monitor) { + defaultService.updateTitleCache(clazz, stepSize, cacheStrategy, monitor); + } + + /** + * @param taxonNode + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List) + */ + @Deprecated + @Override + public TaxonNode loadTaxonNode(TaxonNode taxonNode, List propertyPaths) { + return defaultService.loadTaxonNode(taxonNode, propertyPaths); + } + + /** + * @param t + * @return + * @see eu.etaxonomy.cdm.api.service.IVersionableService#getPreviousAuditEvent(eu.etaxonomy.cdm.model.common.VersionableEntity) + */ + @Override + public AuditEventRecord getPreviousAuditEvent(Classification t) { + return defaultService.getPreviousAuditEvent(t); + } + + /** + * @param clazz + * @return + * @see eu.etaxonomy.cdm.api.service.IService#count(java.lang.Class) + */ + @Override + public int count(Class clazz) { + return defaultService.count(clazz); + } + + /** + * @param clazz + * @param from + * @param to + * @param criteria + * @param pageSize + * @param pageValue + * @param sort + * @param propertyPaths + * @return + * @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) + */ + @Override + public Pager> pageAuditEvents(Class clazz, AuditEvent from, AuditEvent to, List criteria, Integer pageSize, Integer pageValue, AuditEventSort sort, List propertyPaths) { + return defaultService.pageAuditEvents(clazz, from, to, criteria, pageSize, pageValue, sort, propertyPaths); + } + + /** + * @param lsid + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#find(eu.etaxonomy.cdm.model.common.LSID) + */ + @Override + public Classification find(LSID lsid) { + return defaultService.find(lsid); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#delete(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public DeleteResult delete(Classification persistentObject) { + return defaultService.delete(persistentObject); + } + + /** + * @param clazz + * @param technical + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#groupMarkers(java.lang.Class, java.lang.Boolean, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List groupMarkers(Class clazz, Boolean technical, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultService.groupMarkers(clazz, technical, pageSize, pageNumber, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#exists(java.util.UUID) + */ + @Override + public boolean exists(UUID uuid) { + return defaultService.exists(uuid); + } + + /** + * @param x + * @param y + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#replace(eu.etaxonomy.cdm.model.common.IdentifiableEntity, eu.etaxonomy.cdm.model.common.IdentifiableEntity) + */ + @Override + public Classification replace(Classification x, Classification y) { + return defaultService.replace(x, y); + } + + /** + * @param uuidSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.Set) + */ + @Override + public List find(Set uuidSet) { + return defaultService.find(uuidSet); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSources(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getSources(Classification t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultService.getSources(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param classification + * @param rank + * @param pageSize + * @param pageIndex + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#listRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List propertyPaths) { + return defaultService.listRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(java.util.UUID) + */ + @Override + public Classification find(UUID uuid) { + return defaultService.find(uuid); + } + + /** + * @param id + * @return + * @see eu.etaxonomy.cdm.api.service.IService#find(int) + */ + @Override + public Classification find(int id) { + return defaultService.find(id); + } + + /** + * @param t + * @param pageSize + * @param pageNumber + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getRights(eu.etaxonomy.cdm.model.common.IdentifiableEntity, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager getRights(Classification t, Integer pageSize, Integer pageNumber, List propertyPaths) { + return defaultService.getRights(t, pageSize, pageNumber, propertyPaths); + } + + /** + * @param clazz + * @param technical + * @return + * @see eu.etaxonomy.cdm.api.service.IAnnotatableService#countMarkers(java.lang.Class, java.lang.Boolean) + */ + @Override + public int countMarkers(Class clazz, Boolean technical) { + return defaultService.countMarkers(clazz, technical); + } + + /** + * @param idSet + * @return + * @see eu.etaxonomy.cdm.api.service.IService#findById(java.util.Set) + */ + @Override + public List findById(Set idSet) { + return defaultService.findById(idSet); + } + + /** + * @param clazz + * @param idInSource + * @param idNamespace + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#getSourcedObjectByIdInSource(java.lang.Class, java.lang.String, java.lang.String) + */ + @Override + public ISourceable getSourcedObjectByIdInSource(Class clazz, String idInSource, String idNamespace) { + return defaultService.getSourcedObjectByIdInSource(clazz, idInSource, idNamespace); + } + + /** + * @param classification + * @param rank + * @param pageSize + * @param pageIndex + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#pageRankSpecificRootNodes(eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public Pager pageRankSpecificRootNodes(Classification classification, Rank rank, Integer pageSize, Integer pageIndex, List propertyPaths) { + return defaultService.pageRankSpecificRootNodes(classification, rank, pageSize, pageIndex, propertyPaths); + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IService#getSession() + */ + @Override + public Session getSession() { + return defaultService.getSession(); + } + + /** + * @param clazz + * @param limit + * @param start + * @param groups + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#group(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List group(Class clazz, Integer limit, Integer start, List groups, List propertyPaths) { + return defaultService.group(clazz, limit, start, groups, propertyPaths); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public Pager findByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.findByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param baseRank + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranch(eu.etaxonomy.cdm.model.taxon.TaxonNode, eu.etaxonomy.cdm.model.name.Rank, java.util.List) + */ + @Override + public List loadTreeBranch(TaxonNode taxonNode, Rank baseRank, List propertyPaths) { + return defaultService.loadTreeBranch(taxonNode, baseRank, propertyPaths); + } + + /** + * @param type + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#list(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public List list(Class type, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultService.list(type, limit, start, orderHints, propertyPaths); + } + + /** + * @param taxon + * @param classification + * @param baseRank + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadTreeBranchToTaxon(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, eu.etaxonomy.cdm.model.name.Rank, java.util.List) + */ + @Override + public List loadTreeBranchToTaxon(Taxon taxon, Classification classification, Rank baseRank, List propertyPaths) { + return defaultService.loadTreeBranchToTaxon(taxon, classification, baseRank, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#findByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Pager findByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultService.findByTitle(configurator); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(java.lang.Class, java.lang.String, eu.etaxonomy.cdm.persistence.query.MatchMode, java.util.List) + */ + @Override + public Integer countByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria) { + return defaultService.countByTitle(clazz, queryString, matchmode, criteria); + } + + /** + * @param uuid + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID) + */ + @Override + public Classification load(UUID uuid) { + return defaultService.load(uuid); + } + + /** + * @param uuid + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#load(java.util.UUID, java.util.List) + */ + @Override + public Classification load(UUID uuid, List propertyPaths) { + return defaultService.load(uuid, propertyPaths); + } + + /** + * @param configurator + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#countByTitle(eu.etaxonomy.cdm.api.service.config.IIdentifiableEntityServiceConfigurator) + */ + @Override + public Integer countByTitle(IIdentifiableEntityServiceConfigurator configurator) { + return defaultService.countByTitle(configurator); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#merge(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public Classification merge(Classification transientObject) { + return defaultService.merge(transientObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public List listByTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.listByTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param type + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IService#page(java.lang.Class, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager page(Class type, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.page(type, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param propertyPaths + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#loadChildNodesOfTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List) + */ + @Deprecated + @Override + public List loadChildNodesOfTaxonNode(TaxonNode taxonNode, List propertyPaths) { + return defaultService.loadChildNodesOfTaxonNode(taxonNode, propertyPaths); + } + + /** + * @param classification + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(eu.etaxonomy.cdm.model.taxon.Classification) + */ + @Override + public List> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(Classification classification, List excludeTaxa) { + return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeTaxa); + } + + /** + * @param taxon + * @param taxTree + * @param propertyPaths + * @param size + * @param height + * @param widthOrDuration + * @param mimeTypes + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.Taxon, eu.etaxonomy.cdm.model.taxon.Classification, java.util.List, int, int, int, java.lang.String[]) + */ + @Deprecated + @Override + public Map> getAllMediaForChildNodes(Taxon taxon, Classification taxTree, List propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) { + return defaultService.getAllMediaForChildNodes(taxon, taxTree, propertyPaths, size, height, widthOrDuration, mimeTypes); + } + + /** + * @param persistentObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#refresh(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID refresh(Classification persistentObject) { + return defaultService.refresh(persistentObject); + } + + /** + * @param clazz + * @param queryString + * @param matchmode + * @param criteria + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public List listByReferenceTitle(Class clazz, String queryString, MatchMode matchmode, List criteria, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.listByReferenceTitle(clazz, queryString, matchmode, criteria, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param taxonNode + * @param propertyPaths + * @param size + * @param height + * @param widthOrDuration + * @param mimeTypes + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllMediaForChildNodes(eu.etaxonomy.cdm.model.taxon.TaxonNode, java.util.List, int, int, int, java.lang.String[]) + */ + @Override + public Map> getAllMediaForChildNodes(TaxonNode taxonNode, List propertyPaths, int size, int height, int widthOrDuration, String[] mimeTypes) { + return defaultService.getAllMediaForChildNodes(taxonNode, propertyPaths, size, height, widthOrDuration, mimeTypes); + } + + /** + * @param tableName + * @param limit + * @param start + * @return + * @see eu.etaxonomy.cdm.api.service.IService#rows(java.lang.String, int, int) + */ + @Override + public List rows(String tableName, int limit, int start) { + return defaultService.rows(tableName, limit, start); + } + + /** + * @param newInstances + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(java.util.Collection) + */ + @Override + public Map save(Collection newInstances) { + return null; + } + + /** + * @param taxonNode + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode) + */ + @Deprecated + @Override + public UUID removeTaxonNode(TaxonNode taxonNode) { + return defaultService.removeTaxonNode(taxonNode); + } + + /** + * @param taxonNode + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNode(eu.etaxonomy.cdm.model.taxon.TaxonNode) + */ + @Deprecated + @Override + public UUID saveTaxonNode(TaxonNode taxonNode) { + return null; + } + + /** + * @param newInstance + * @return + * @see eu.etaxonomy.cdm.api.service.IService#save(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public Classification save(Classification newInstance) { + return null; + } + + /** + * @param taxonNodeCollection + * @return + * @deprecated + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTaxonNodeAll(java.util.Collection) + */ + @Deprecated + @Override + public Map saveTaxonNodeAll(Collection taxonNodeCollection) { + return null; + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID saveOrUpdate(Classification transientObject) { + return null; + } + + /** + * @param treeNode + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#removeTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode) + */ + @Override + public UUID removeTreeNode(ITaxonTreeNode treeNode) { + return defaultService.removeTreeNode(treeNode); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param propertyPaths + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#search(java.lang.Class, java.lang.String, java.lang.Integer, java.lang.Integer, java.util.List, java.util.List) + */ + @Override + public Pager search(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, List propertyPaths) { + return defaultService.search(clazz, queryString, pageSize, pageNumber, orderHints, propertyPaths); + } + + /** + * @param treeNode + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#saveTreeNode(eu.etaxonomy.cdm.model.taxon.ITaxonTreeNode) + */ + @Override + public UUID saveTreeNode(ITaxonTreeNode treeNode) { + return null; + } + + /** + * @param transientObjects + * @return + * @see eu.etaxonomy.cdm.api.service.IService#saveOrUpdate(java.util.Collection) + */ + @Override + public Map saveOrUpdate(Collection transientObjects) { + return null; + } + + /** + * @return + * @see eu.etaxonomy.cdm.api.service.IClassificationService#getAllNodes() + */ + @Override + public List getAllNodes() { + return defaultService.getAllNodes(); + } + + /** + * @param transientObject + * @return + * @see eu.etaxonomy.cdm.api.service.IService#update(eu.etaxonomy.cdm.model.common.ICdmBase) + */ + @Override + public UUID update(Classification transientObject) { + return defaultService.update(transientObject); + } + + /** + * @param example + * @param includeProperties + * @param limit + * @param start + * @param orderHints + * @param propertyPaths + * @return + * @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) + */ + @Override + public List list(Classification example, Set includeProperties, Integer limit, Integer start, List orderHints, List propertyPaths) { + return defaultService.list(example, includeProperties, limit, start, orderHints, propertyPaths); + } + + /** + * @param clazz + * @param matchStrategy + * @param mergeStrategy + * @return + * @see eu.etaxonomy.cdm.api.service.IIdentifiableEntityService#deduplicate(java.lang.Class, eu.etaxonomy.cdm.strategy.match.IMatchStrategy, eu.etaxonomy.cdm.strategy.merge.IMergeStrategy) + */ + @Override + public int deduplicate(Class clazz, IMatchStrategy matchStrategy, IMergeStrategy mergeStrategy) { + return defaultService.deduplicate(clazz, matchStrategy, mergeStrategy); + } + + /** + * @param clazz + * @param queryString + * @param pageSize + * @param pageNumber + * @param orderHints + * @param matchMode + * @return + * @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) + */ + @Override + public Pager findTitleCache(Class clazz, String queryString, Integer pageSize, Integer pageNumber, List orderHints, MatchMode matchMode) { + return defaultService.findTitleCache(clazz, queryString, pageSize, pageNumber, orderHints, matchMode); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IClassificationService#listChildNodesOfTaxon(java.util.UUID, java.util.UUID, java.lang.Integer, java.lang.Integer, java.util.List) + */ + @Override + public List listChildNodesOfTaxon(UUID taxonUuid, UUID classificationUuid, Integer pageSize, + Integer pageIndex, List propertyPaths) { + return defaultService.listChildNodesOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths); + } + + @Override + public DeleteResult isDeletable(Classification object, + DeleteConfiguratorBase config) { + // TODO Auto-generated method stub + return null; + } + + @Override + public Classification findWithoutFlush(UUID uuid) { + return defaultService.findWithoutFlush(uuid); + } + + + @Override + public Pager> findByIdentifier(Class clazz, String identifier, DefinedTerm identifierType, MatchMode matchmode, boolean includeEntity, Integer pageSize, Integer pageNumber, List propertyPaths){ + return defaultService.findByIdentifier(clazz, identifier, identifierType, matchmode, includeEntity, pageSize, pageNumber, propertyPaths); + } + + @Override + public UpdateResult createHierarchyInClassification(Classification arg1, CreateHierarchyForClassificationConfigurator arg2) { + return defaultService.createHierarchyInClassification(arg1, arg2); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.UUID) + */ + @Override + public DeleteResult delete(UUID arg0) { + return defaultService.delete(arg0); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#delete(java.util.Collection) + */ + @Override + public DeleteResult delete(Collection arg0) { + return defaultService.delete(arg0); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List) + */ + @Override + public List merge(List arg0) { + return defaultService.merge(arg0); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#merge(java.util.List, boolean) + */ + @Override + public List> merge(List 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 merge(Classification arg0, boolean arg1) { + return defaultService.merge(arg0, arg1); + } + + /* (non-Javadoc) + * @see eu.etaxonomy.cdm.api.service.IService#loadWithUpdate(java.util.UUID) + */ + @Override + public Classification loadWithUpdate(UUID arg0) { + return defaultService.loadWithUpdate(arg0); + } + + + @Override + public List> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification( + UUID classificationUuid, List excludeTaxa) { + + return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, excludeTaxa); + } + + /** + * {@inheritDoc} + */ + @Override + public List load(List arg0, List arg1) { + return defaultService.load(arg0, arg1); + } + + @Override + public List> getUuidAndTitleCache(Integer limit, String pattern) { + return defaultService.getUuidAndTitleCache(null, null); + } + + @Override + public List> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification( + UUID classificationUuid, List excludeTaxa, Integer limit, + String pattern) { + return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classificationUuid, excludeTaxa, limit, pattern); + } + + @Override + public List> getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification( + Classification classification, List excludeTaxa, + Integer limit, String pattern) { + return defaultService.getTaxonNodeUuidAndTitleCacheOfAcceptedTaxaByClassification(classification, excludeTaxa, limit, pattern); + } + + @Override +<<<<<<< HEAD + public List listSiblingsOfTaxon(UUID taxonUuid, UUID classificationUuid, Integer pageSize, Integer pageIndex, + List propertyPaths) { + return defaultService.listSiblingsOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, + propertyPaths); +======= + public List listSiblingsOfTaxon(UUID taxonUuid, + UUID classificationUuid, Integer pageSize, Integer pageIndex, + List propertyPaths) { + + return defaultService.listSiblingsOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths); + } + + @Override + public Pager pageSiblingsOfTaxon(UUID taxonUuid, + UUID classificationUuid, Integer pageSize, Integer pageIndex, + List propertyPaths) { + return defaultService.pageSiblingsOfTaxon(taxonUuid, classificationUuid, pageSize, pageIndex, propertyPaths); +>>>>>>> fix compile errros in classification service + } + + +} diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientCollectionService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientCollectionService.java index 7ca4d3d89..b5a90a724 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientCollectionService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientCollectionService.java @@ -754,10 +754,9 @@ public class TransientCollectionService implements ICollectionService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientDescriptionService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientDescriptionService.java index f1d24b78d..165678450 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientDescriptionService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientDescriptionService.java @@ -1239,10 +1239,9 @@ public class TransientDescriptionService implements IDescriptionService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientNameService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientNameService.java index f9ff627df..152481b73 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientNameService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientNameService.java @@ -1232,9 +1232,9 @@ public class TransientNameService implements INameService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + public List loadByIds(List idSet, List propertyPaths) { + + return defaultService.loadByIds(idSet, propertyPaths); } } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientOccurenceService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientOccurenceService.java index 9162cc2ab..52605735c 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientOccurenceService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientOccurenceService.java @@ -1105,10 +1105,9 @@ public class TransientOccurenceService implements IOccurrenceService { } @Override - public List listByIds(Set arg0, - Integer arg1, Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientReferenceService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientReferenceService.java index aff289516..888ae989e 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientReferenceService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientReferenceService.java @@ -766,10 +766,9 @@ public class TransientReferenceService implements IReferenceService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java index 435bdc9ff..e43f01168 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTaxonService.java @@ -1551,10 +1551,9 @@ public class TransientTaxonService implements ITaxonService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } diff --git a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTermService.java b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTermService.java index 19ef7de34..0d6e58a85 100644 --- a/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTermService.java +++ b/eu.etaxonomy.taxeditor.editor/src/main/java/eu/etaxonomy/taxeditor/editor/view/dataimport/transientServices/TransientTermService.java @@ -920,9 +920,8 @@ public class TransientTermService implements ITermService { } @Override - public List listByIds(Set arg0, Integer arg1, - Integer arg2, List arg3, List arg4) { + public List loadByIds(List idSet, List propertyPaths) { - return defaultService.listByIds(arg0, arg1, arg2, arg3, arg4); + return defaultService.loadByIds(idSet, propertyPaths); } } -- 2.34.1