EDIT

    protected DeleteResult doInvoke() {

        try {

            double start = System.currentTimeMillis();

            IProgressMonitor monitor = getConfig().getMonitor();

            logger.info("Time elapsed for invoking task(): " + (end - start) / (1000) + "s");

            done();

        } catch (Exception e) {

            getResult().addException(new RuntimeException("Unhandled error during doInvoke", e));

        }

    }

    private DeleteResult handleException(Exception e, String unhandledMessage) {

        }

        //persist

        deleteDescriptionsToDelete(resultHolder);

    }

                getSession().flush(); // move to service method #9801

                DeleteResult descriptionDeleteResult = repository.getDescriptionService().deleteDescription(descriptionToDelete);

                //TODO handle result somehow if not OK, but careful, descriptions may be linked >1x and therefore maybe deleted only after last link was removed

            }

        }

    }

     * Removes description elements not needed anymore from their description and

     * updates the {@link DeleteResult}.

     */

            Set<? extends DescriptionElementBase> elementsToRemove) {

        //remove all elements not needed anymore

        for(DescriptionElementBase elementToRemove : elementsToRemove){

            targetDescription.removeElement(elementToRemove);

            //AM: do we really want to add each element to the deleteResult?

        }

    }

    /**

     * Adds the temporary aggregated data (resultHolder) to the description.

     * Tries to reuse existing data if possible.

     */

            ResultHolder resultHolder);

    protected abstract void aggregateToParentTaxon(TaxonNode taxonNode, ResultHolder resultHolder,

        // create a new one

        TaxonDescription newDescription = createNewDescription(taxon);

        return newDescription;

    }

            for(DescriptionElementBase descriptionElement : deleteCandidates) {

                aggregationDescription.removeElement(descriptionElement);

                getDescriptionService().deleteDescriptionElement(descriptionElement);

            }

            getDescriptionService().saveOrUpdate(aggregationDescription);

        }

    }

            TaxonDescription targetDescription, Map<TE, S> newElementsMap, Class<S> debClass) {

        //init elements to remove

        Set<DescriptionElementBase> elementsToRemove = new HashSet<>(

                targetDescription.getElements().stream()

            //if there is no element for this character in old data, add the new element for this character to the target description (otherwise reuse old element)

            if (elementToStay == null){

                targetDescription.addElement(newElement);

            }else{

                elementsToRemove.remove(elementToStay);

            }

        }

    }

    /**

     * Merges a new (temporary description element into an existing one)

     */

    protected abstract <S extends DescriptionElementBase>

        Set<DescriptionElementSource> toDeleteSources = new HashSet<>(deb.getSources());

        for(DescriptionElementSource newSource : newSources) {

            boolean contained = false;

            if(!contained) {

                try {

                    deb.addSource(newSource.clone());

                } catch (CloneNotSupportedException e) {

                    // should never happen

                    throw new RuntimeException(e);

        }

        for (DescriptionElementSource toDeleteSource : toDeleteSources){

            deb.removeSource(toDeleteSource);

        }

    }

    protected abstract TaxonDescription createNewDescription(Taxon taxon);

import org.hibernate.search.Search;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.description.DescriptionElementBase;

    }

    @Override

            ResultHolder resultHolder) {

        Class<? extends DescriptionElementBase> debClass = Distribution.class;

        Map<NamedArea, Distribution> accumulatedStatusMap = ((DistributionResultHolder)resultHolder).accumulatedStatusMap;

                // create a new distribution element

                targetDistribution = newElement;

                targetDescription.addElement(targetDistribution);

            }else{

                elementsToRemove.remove(targetDistribution);  //we keep the distribution for reuse

            }

        }

    }

    @Override

            S newElement) {

        if (!(targetElement instanceof Distribution)){

            throw new AggregationException("Unexpected class: " + targetElement.getClass().getName());

        }else{

            Distribution targetDistribution = (Distribution)targetElement;

            Distribution newDistribution = (Distribution)newElement;

        }

    }

    @Override

import java.util.stream.Collectors;

import eu.etaxonomy.cdm.common.BigDecimalUtil;

import eu.etaxonomy.cdm.common.monitor.IProgressMonitor;

import eu.etaxonomy.cdm.model.common.CdmBase;

import eu.etaxonomy.cdm.model.common.ICdmBase;

    }

    @Override

            ResultHolder resultHolder) {

        StructuredDescriptionResultHolder structuredResultHolder = (StructuredDescriptionResultHolder)resultHolder;

        if(!targetDescription.getElements().isEmpty()){

            dataSet.addDescription(targetDescription);

        }else{

            dataSet.removeDescription(targetDescription);

        }

    }

    @Override

        return deb.isInstanceOf(CategoricalData.class) || deb.isInstanceOf(QuantitativeData.class);

    }

                StructuredDescriptionResultHolder structuredResultHolder) {

        //Remove sources from description

        Set<IdentifiableSource> sourcesToRemove = targetDescription.getSources().stream()

                .filter(source->source.getType().equals(OriginalSourceType.Aggregation))

            IdentifiableSource mergeSourceCandidate = findSourceCandidate(targetDescription, newSource);

            if (mergeSourceCandidate == null){

                addNewSource(targetDescription, newSource);

            }else{

                sourcesToRemove.remove(mergeSourceCandidate);

            }

        }

        //remove remaining sources-to-be-removed

        for (IdentifiableSource sourceToRemove : sourcesToRemove) {

            targetDescription.removeSource(sourceToRemove);

            ICdmBase target = CdmBase.deproxy(sourceToRemove.getCdmSource());

            if (target != null){

                sourceToRemove.setCdmSource(null); //workaround for missing orphan removal #9801

                }

            }

        }

    }

    private <T extends DescriptionBase<?>> void addNewSource(TaxonDescription targetDescription,

    }

    //mergeablity has been checked before

        ICdmBase newTarget = newSource.getCdmSource();

        if (newTarget != null){

            newTarget = CdmBase.deproxy(newTarget);

                T newTargetDesc = (T)newTarget;

                @SuppressWarnings("unchecked")

                T existingTargetDesc = CdmBase.deproxy((T)mergeCandidate.getCdmSource());

                ((IDescribable<T>)existingTargetDesc.describedEntity()).addDescription(existingTargetDesc);

                if (!existingTargetDesc.equals(newTargetDesc)){

                    ((IDescribable<T>)newTargetDesc.describedEntity()).removeDescription(newTargetDesc);

        }else{

            throw new AggregationException("Sources not linking to another CdmBase instance currently not yet supported.");

        }

    }

        Set<DescriptionElementBase> elementsToRemove = new HashSet<>(existingSourceDescription.getElements());

        Set<DescriptionElementBase> newElements = new HashSet<>(newSourceDescription.getElements());

                        && e.getFeature().equals(newElementClone.getFeature()))

                    .findFirst();

            if (matchingElement.isPresent()){

                elementsToRemove.remove(matchingElement.get());

            }else{

                existingSourceDescription.addElement(newElementClone);

            }

        }

        existingSourceDescription.setTitleCache(newSourceDescription.getTitleCache(), true);

        for (DescriptionElementBase debToRemove : elementsToRemove){

            existingSourceDescription.removeElement(debToRemove);

        }

    }

    @SuppressWarnings("unchecked")

    }

    private IdentifiableSource findSourceCandidate(TaxonDescription targetDescription, IdentifiableSource newSource) {

    }

    @Override

            S newElement) {

        targetElement = CdmBase.deproxy(targetElement);

        newElement = CdmBase.deproxy(newElement);

        if (targetElement instanceof CategoricalData){

        }else if (targetElement.isInstanceOf(QuantitativeData.class)){

        }else{

            throw new AggregationException("Class not supported: " + targetElement.getClass().getName());

        }

    }

            CategoricalData newElement) {

        List<StateData> newData = new ArrayList<>(newElement.getStateData());

        for (StateData newStateData : newData){

            State state = newStateData.getState();

            if (oldStateData != null){

                //for now only state and count is used for aggregation, below code needs to be adapted if this changes

            }else{

                elementToStay.addStateData(newStateData);

            }

        }

            elementToStay.removeStateData(stateDataToRemove);

        }

    }

    private StateData firstByState(State state, List<StateData> oldData) {

        return null;

    }

            QuantitativeData newElement) {

        Set<StatisticalMeasurementValue> oldValues = new HashSet<>(elementToStay.getStatisticalValues());

        Set<StatisticalMeasurementValue> newValues = new HashSet<>(newElement.getStatisticalValues());

        for (StatisticalMeasurementValue newValue : newValues){

            StatisticalMeasurementValue oldValue = firstValueByType(type, oldValues);

            if (oldValue != null){

                //for now only state and count is used for aggregation, below code needs to be adapted if this changes

                oldValues.remove(oldValue);

            }else{

                elementToStay.addStatisticalValue(newValue);

            }

        }

        for (StatisticalMeasurementValue valueToRemove : oldValues){

            elementToStay.removeStatisticalValue(valueToRemove);

        }

    }

    private StatisticalMeasurementValue firstValueByType(StatisticalMeasure type, Set<StatisticalMeasurementValue> oldValues) {

        // 1st aggregation

        DeleteResult result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        addSomeDataToFirstAggregation();

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config).setWithAddedData());

        // 2nd aggregation => should be same as originally as data was only added to aggregation to see if it is correctly deleted

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        addNewFeature();

        commitAndStartNewTransaction();

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config).setWithFeature());

    }

    private void addSomeDataToFirstAggregation() {

        @DataSet(value="StructuredDescriptionAggregationTest.xml"),

    })

    public void testDeleteTest() {

        createDefaultFeatureTree();

        DescriptiveDataSet dataSet = createTestData();

        commitAndStartNewTransaction();

        // 1st aggregation

        DeleteResult result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        removeSomeDataFromFirstAggregation();

        commitAndStartNewTransaction();

        Assert.assertEquals("Should have 3 specimen desc, 1 literature desc, 2 individual association holder, "

        // 2nd aggregation

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config).setWithRemoved());

    }

        @DataSet(value="StructuredDescriptionAggregationTest.xml"),

    })

    public void testIncompleteQuantitativeData() {

        createDefaultFeatureTree();

        DescriptiveDataSet dataSet = DescriptiveDataSet.NewInstance();

        datasetService.save(dataSet);

        dataSet.setDescriptiveSystem(descriptiveSystem);

        commitAndStartNewTransaction();

        StructuredDescriptionAggregationConfiguration config = createConfig(dataSet);

        DeleteResult result = engine.invoke(config, repository);

        Taxon taxLapsanaCommunisAlpina = (Taxon)taxonService.find(T_LAPSANA_COMMUNIS_ALPINA_UUID);

        TaxonDescription aggrDescLapsanaCommunisAlpina = verifyTaxonDescriptions(taxLapsanaCommunisAlpina, 1);

        verifyQuantitativeData(uuidFeatureLeafLength, null, new BigDecimal("0.0"), new BigDecimal("7.0"), null, aggrDescLapsanaCommunisAlpina);

        verifyStatusOk(result);

        Taxon taxLapsanaCommunisAlpina = (Taxon)taxonService.find(T_LAPSANA_COMMUNIS_ALPINA_UUID);

        //if no state at all exists in description even the description is not created (this was different before but changed with 9b8a8049439 / #9804)

        verifyNumberTaxonDescriptions(taxLapsanaCommunisAlpina, 0);

        //add data for another feature

        commitAndStartNewTransaction();

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        taxLapsanaCommunisAlpina = (Taxon)taxonService.find(T_LAPSANA_COMMUNIS_ALPINA_UUID);

        TaxonDescription aggrDescLapsanaCommunisAlpina = verifyTaxonDescriptions(taxLapsanaCommunisAlpina, 1);

        verifyNumberDescriptionElements(aggrDescLapsanaCommunisAlpina, uuidFeatureLeafColor, 0);  //we don't expect empty categorical data anymore #9804

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        taxLapsanaCommunisAlpina = (Taxon)taxonService.find(T_LAPSANA_COMMUNIS_ALPINA_UUID);

        aggrDescLapsanaCommunisAlpina = verifyTaxonDescriptions(taxLapsanaCommunisAlpina, 2);  //for leafPA and for color

        List<StateData> sdAlpinaLeafColor = verifyCategoricalData(uuidFeatureLeafColor, 1, aggrDescLapsanaCommunisAlpina, false);

        // 1st aggregation

        DeleteResult result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        config.setToParentSourceMode(AggregationSourceMode.NONE);

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        config.setToParentSourceMode(AggregationSourceMode.DESCRIPTION);

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        config.setToParentSourceMode(AggregationSourceMode.TAXON);

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        config.setToParentSourceMode(AggregationSourceMode.TAXON);

        result = engine.invoke(config, repository);

        verifyStatusOk(result);

        commitAndStartNewTransaction();

        verifyAggregatedDescription(new TestConfig(config));

        @DataSet(value="StructuredDescriptionAggregationTest.xml"),

    })

    public void testAggregation() {

        createDefaultFeatureTree();

        DescriptiveDataSet dataSet = createTestData();

        commitAndStartNewTransaction();

        StructuredDescriptionAggregationConfiguration config = createConfig(dataSet);

        DeleteResult result = engine.invoke(config, repository);

        commitAndStartNewTransaction();

        verifyStatusOk(result);

        verifyAggregatedDescription(new TestConfig(config));

        config.setIncludeLiterature(true);

        result = engine.invoke(config, repository);

        commitAndStartNewTransaction();

        verifyStatusOk(result);

        }

    }

    private void verifyStatusError(DeleteResult result, String expectedMessage) {

        if (result.getStatus() != DeleteResult.Status.ERROR){

            Assert.fail("Aggregation should fail with status error " + result.toString());