EDIT

    static final int partitionSize = 5000;

    static final boolean doConcurrent = false;

// ***************** ALL ************************************************//

//    >50 records

    //>17000 records

//    UUID uuidTaxonNodeFilter = UUID.fromString("7ee4983b-78a3-44c5-9af2-beb0494b5fc8");

    private void doImport(ICdmDataSource source, ICdmDataSource destination, DbSchemaValidation hbm2dll){

        FauEu2CdmImportConfigurator config = FauEu2CdmImportConfigurator.NewInstance(source,  destination);

        config.setConcurrent(doConcurrent);

        IProgressMonitor monitor = config.getProgressMonitor();

        config.setCheck(check);

//        config.setRecordsPerTransaction(partitionSize);

        // invoke import

        CdmDefaultImport<FauEu2CdmImportConfigurator> myImport = new CdmDefaultImport<>();

        myImport.invoke(config);

        System.out.println("End" + importFrom);

    }

    public static void main(String[] args) {

        ICdmDataSource cdmDB = CdmDestinations.chooseDestination(args) != null ? CdmDestinations.chooseDestination(args) : cdmDestination;

        FauEu2CdmActivator myImport = new FauEu2CdmActivator();

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

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

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

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

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

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

import eu.etaxonomy.cdm.model.name.HybridRelationship;

import eu.etaxonomy.cdm.model.name.NameRelationship;

import eu.etaxonomy.cdm.model.name.NomenclaturalStatus;

import eu.etaxonomy.cdm.model.name.Registration;

import eu.etaxonomy.cdm.model.name.TaxonName;

import eu.etaxonomy.cdm.model.name.TypeDesignationBase;

    private static final long serialVersionUID = 8917991155285743172L;

    private static final Logger logger = Logger.getLogger(FauEu2CdmImportBase.class);

    //TODO move to state

    private Map<UUID, CdmBase> sessionCache = new HashMap<>();

    protected Set<CdmBase> toSave = new HashSet<>();

        return detache(cdmBase, false);

    }

    protected <T extends CdmBase> T detache(T cdmBase, boolean notFromSource) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        cdmBase = CdmBase.deproxy(cdmBase);

        if (cdmBase == null ){

        }else if(isInCache(cdmBase)){

            return getCached(cdmBase);

        }else {

                Class<T> clazz = (Class<T>)cdmBase.getClass();

                }

            }

        }

        }

    }

    protected <A extends CdmBase> CdmBase handlePersisted(A cdmBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        if(cdmBase instanceof TaxonNode){

            return handlePersistedTaxonNode((TaxonNode)cdmBase);

            return handlePersistedIntextReference((IntextReference)cdmBase);

        }else if(cdmBase instanceof ExtensionType){

            return handlePersistedExtensionType((ExtensionType)cdmBase);

        }else if(cdmBase instanceof DefinedTerm){

            return handlePersistedDefinedTerm((DefinedTerm)cdmBase);

        }else if(cdmBase instanceof DefinedTermBase){

        if (result ==null){

            return result;

        }

        handleCollection(result, TaxonNode.class, "agentRelations", TaxonNodeAgentRelation.class);

        result.setTaxon(detache(result.getTaxon()));

        result.setReference(detache(node.getReference()));

        handleMap(result, TaxonNode.class, "excludedNote", Language.class, LanguageString.class);

        //classification, parent, children

        this.setInvisible(node, "classification", detache(node.getClassification()));

    protected Taxon handlePersistedTaxon(Taxon taxon) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Taxon result = handlePersisted((TaxonBase)taxon);

        handleCollection(result, Taxon.class, "synonyms", Synonym.class);

//        handleCollection(result, Taxon.class, "taxonNodes", TaxonNode.class);

        setNewCollection(result, Taxon.class, "taxonNodes", TaxonNode.class);

        handleCollection(result, Taxon.class, "relationsFromThisTaxon", TaxonRelationship.class);

        handleCollection(result, Taxon.class, "relationsToThisTaxon", TaxonRelationship.class);

        return result;

    }

    protected Synonym handlePersistedSynonym(Synonym synonym) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Synonym result = handlePersisted((TaxonBase)synonym);

        setInvisible(result, "acceptedTaxon", detache(result.getAcceptedTaxon()));

        result.setType(detache(result.getType()));

        return result;

    protected TaxonRelationship handlePersistedTaxonRelationship(TaxonRelationship taxRel) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        TaxonRelationship result = handlePersisted((RelationshipBase)taxRel);

        result.setFromTaxon(detache(result.getFromTaxon()));

        result.setToTaxon(detache(result.getToTaxon()));

        result.setType(detache(result.getType()));

    protected NameRelationship handlePersistedNameRelationship(NameRelationship rel) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        NameRelationship result = handlePersisted((RelationshipBase)rel);

        setInvisible(result, "relatedFrom", detache(result.getFromName()));

        setInvisible(result, "relatedTo", detache(result.getToName()));

//        result.setFromName(detache(result.getFromName()));

    protected HybridRelationship handlePersistedHybridRelationship(HybridRelationship rel) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        HybridRelationship result = handlePersisted((RelationshipBase)rel);

        setInvisible(result, "relatedFrom", detache(result.getParentName()));

        setInvisible(result, "relatedTo", detache(result.getHybridName()));

//        result.setFromName(detache(result.getFromName()));

    protected NomenclaturalStatus handlePersistedNomenclaturalStatus(NomenclaturalStatus status) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        NomenclaturalStatus result = handlePersisted((ReferencedEntityBase)status);

        result.setType(detache(result.getType()));

        return result;

    }

    protected TypeDesignationBase handlePersistedTypeDesignationBase(TypeDesignationBase<?> designation) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        TypeDesignationBase result = handlePersisted((SourcedEntityBase)designation);

        result.setCitation(detache(result.getCitation()));

        handleCollection(result, TypeDesignationBase.class, "registrations", Registration.class);

        handleCollection(result, TypeDesignationBase.class, "typifiedNames", TaxonName.class);

    protected InstitutionalMembership handlePersistedInstitutionalMembership(InstitutionalMembership institutionalMembership) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        InstitutionalMembership result = handlePersisted((VersionableEntity)institutionalMembership);

//        result.setPerson(detache(result.getPerson()));

        setInvisible(result, "person", detache(result.getPerson()));

        result.setInstitute(detache(result.getInstitute()));

    protected Institution handlePersistedInstitution(Institution institution) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Institution result = handlePersisted((AgentBase)institution);

        result.setIsPartOf(detache(result.getIsPartOf()));

        handleCollection(result, Institution.class, "types", DefinedTerm.class);

        return result;

    protected TaxonNodeAgentRelation handlePersistedTaxonNodeAgentRelation(TaxonNodeAgentRelation nodeAgentRel) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        TaxonNodeAgentRelation result = handlePersisted((AnnotatableEntity)nodeAgentRel);

        result.setAgent(detache(result.getAgent()));

        result.setType(detache(result.getType()));

        setInvisible(result, "taxonNode", detache(result.getTaxonNode()));

    protected TaxonName handlePersistedTaxonName(TaxonName taxonName) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        @SuppressWarnings("rawtypes")

        TaxonName result = handlePersisted((IdentifiableEntity)taxonName);

        result.setCombinationAuthorship(detache(result.getCombinationAuthorship()));

        result.setExCombinationAuthorship(detache(result.getExCombinationAuthorship()));

        result.setBasionymAuthorship(detache(result.getBasionymAuthorship()));

        result.setInCombinationAuthorship(detache(result.getInCombinationAuthorship()));

        result.setNomenclaturalReference(detache(result.getNomenclaturalReference()));

        result.setHomotypicalGroup(detache(result.getHomotypicalGroup()));

        handleCollection(result, TaxonName.class, "descriptions", TaxonNameDescription.class);

        handleCollection(result, TaxonName.class, "hybridChildRelations", HybridRelationship.class);

    protected HomotypicalGroup handlePersistedHomotypicalGroup(HomotypicalGroup group) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        HomotypicalGroup result = handlePersisted((AnnotatableEntity)group);

        handleCollection(result, HomotypicalGroup.class, "typifiedNames", TaxonName.class);

        return result;

    }

    protected Annotation handlePersistedAnnotation(Annotation annotation) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Annotation result = handlePersisted((AnnotatableEntity)annotation);

        result.setAnnotationType(detache(annotation.getAnnotationType()));

        handleCollection(result, Annotation.class, "intextReferences", IntextReference.class);

        return result;

    }

    protected Extension handlePersistedExtension(Extension extension) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Extension result = handlePersisted((VersionableEntity)extension);

        result.setType(detache(extension.getType()));

        return result;

    }

    protected Marker handlePersistedMarker(Marker marker) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Marker result = handlePersisted((VersionableEntity)marker);

        result.setMarkerType(detache(marker.getMarkerType()));

        return result;

    }

    protected Team handlePersistedTeam(Team team) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Team result = handlePersisted((TeamOrPersonBase)team);

        handleCollection(result, Team.class, "teamMembers", Person.class);

        return result;

    }

    protected Person handlePersistedPerson(Person person) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Person result = handlePersisted((TeamOrPersonBase)person);

        handleCollection(result, Person.class, "institutionalMemberships", InstitutionalMembership.class);

        return result;

    }

    protected NamedArea handlePersistedNamedArea(NamedArea area) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        NamedArea result = handlePersisted((OrderedTermBase)area);

        handleCollection(result, NamedArea.class, "countries", Country.class);

        result.setLevel(detache(result.getLevel()));

        result.setType(detache(result.getType()));

    protected Classification handlePersistedClassification(Classification classification) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        Classification result = handlePersisted((IdentifiableEntity)classification);

        result.setName(detache(classification.getName()));

        result.setReference(detache(classification.getReference()));

        result.setRootNode(detache(classification.getRootNode()));

        handleCollection(result, Classification.class, "geoScopes", NamedArea.class);

        handleMap(result, Classification.class, "description", Language.class, LanguageString.class);

        return result;

    }

    }

    protected SpecimenOrObservationBase<?> handlePersistedSpecimenOrObservationBase(SpecimenOrObservationBase specimen) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        SpecimenOrObservationBase<?> result = handlePersisted((IdentifiableEntity)specimen);

        result.setSex(detache(result.getSex()));

        result.setLifeStage(detache(result.getLifeStage()));

        result.setKindOfUnit(detache(result.getKindOfUnit()));

        handleCollection(result, SpecimenOrObservationBase.class, "determinations", DeterminationEvent.class);

        handleCollection(result, SpecimenOrObservationBase.class, "descriptions", SpecimenDescription.class);

        handleCollection(result, SpecimenOrObservationBase.class, "derivationEvents", DerivationEvent.class);

    protected IdentifiableSource handlePersistedIdentifiableSource(IdentifiableSource source) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        IdentifiableSource result = handlePersisted((OriginalSourceBase)source);

        return result;

    }

    protected DescriptionElementSource handlePersistedDescriptionElementSource(DescriptionElementSource source) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        DescriptionElementSource result = handlePersisted((OriginalSourceBase)source);

        result.setNameUsedInSource(detache(result.getNameUsedInSource()));

        return result;

    }

    protected <T extends CommonTaxonName> T  handlePersistedCommonTaxonName(CommonTaxonName element) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((DescriptionElementBase)element);

        result.setLanguage(detache(result.getLanguage()));

        result.setArea(detache(result.getArea()));

        return result;

    protected <T extends TextData> T  handlePersistedTextData(TextData element) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((DescriptionElementBase)element);

        result.setFormat(detache(result.getFormat()));

        handleMap(result, TextData.class, "multilanguageText", Language.class, LanguageString.class);

        return result;

    protected <T extends Distribution> T  handlePersistedDistribution(Distribution element) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((DescriptionElementBase)element);

        result.setArea(detache(result.getArea()));

        result.setStatus(detache(result.getStatus()));

        return result;

    protected ExtensionType handlePersistedExtensionType(ExtensionType term) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        ExtensionType result = handlePersisted((DefinedTermBase)term);

        return result;

    }

    protected DefinedTerm handlePersistedDefinedTerm(DefinedTerm term) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        DefinedTerm result = handlePersisted((DefinedTermBase)term);

        return result;

    }

    //placeholder for not implemented methods for subclasses

    protected DefinedTermBase<?> handlePersistedTerm(DefinedTermBase term) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        DefinedTermBase<?> result = handlePersisted(term);

        return result;

    }

    protected TermNode<?> handlePersistedTermNode(TermNode node) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        TermNode<?> result = (TermNode<?>)handlePersisted((TermRelationBase)node);

        setInvisible(result, "parent", detache(result.getParent()));

        handleCollection(result, TermNode.class, "inapplicableIf", FeatureState.class);

        handleCollection(result, TermNode.class, "onlyApplicableIf", FeatureState.class);

    protected <T extends TermBase> T  handlePersisted(TermBase termBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((IdentifiableEntity)termBase);

        handleCollection(result, TermBase.class, "representations", Representation.class);

        return result;

    }

    protected <T extends TermCollection> T  handlePersisted(TermCollection termCollection) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((TermBase)termCollection);

        handleCollection(result, TermCollection.class, "termRelations", TermRelationBase.class);

        return result;

    }

        User result = (User)handlePersistedCdmBase(user);

        if (result.getUsername().equals("admin")){

            result = getUserService().listByUsername("admin", MatchMode.EXACT, null, null, null, null, null).iterator().next();

            cache(result); //necessary?

            toSave.add(result);

            toSave.remove(user);

    protected LanguageString handlePersistedLanguageString(LanguageString languageString) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        LanguageString result = handlePersisted((LanguageStringBase)languageString);

        handleCollection(result, LanguageString.class, "intextReferences", IntextReference.class);

        return result;

    }

    protected <T extends TaxonDescription> T  handlePersistedTaxonDescription(TaxonDescription taxDescription) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((DescriptionBase)taxDescription);

        setInvisible(taxDescription, "taxon", detache(taxDescription.getTaxon()));

        handleCollection(taxDescription, TaxonDescription.class, "geoScopes", NamedArea.class);

        handleCollection(taxDescription, TaxonDescription.class, "scopes", DefinedTerm.class);

    protected <T extends TaxonDescription> T  handlePersistedTaxonNameDescription(TaxonNameDescription nameDescription) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((DescriptionBase)nameDescription);

        setInvisible(nameDescription, "taxonName", detache(nameDescription.getTaxonName()));

        return result;

    }

    protected <T extends CdmBase> T handlePersistedCdmBase(CdmBase cdmBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = (T)getTarget(cdmBase);

        cdmBase.setCreatedBy(detache(cdmBase.getCreatedBy()));

        return result;

    }

    protected <T extends VersionableEntity> T handlePersisted(VersionableEntity entity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = (T)handlePersistedCdmBase((CdmBase)entity);

        entity.setUpdatedBy(detache(entity.getUpdatedBy()));

        return result;

    }

    protected <T extends AnnotatableEntity> T handlePersisted(AnnotatableEntity entity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((VersionableEntity)entity);

        handleCollection(result, AnnotatableEntity.class, "annotations", Annotation.class);

        handleCollection(result, AnnotatableEntity.class, "markers", Marker.class);

        return result;

    protected <T extends SourcedEntityBase> T  handlePersisted(SourcedEntityBase sourcedEntity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((AnnotatableEntity)sourcedEntity);

        handleCollection(result, SourcedEntityBase.class, "sources", OriginalSourceBase.class);

        return result;

    }

    protected <T extends IdentifiableEntity> T  handlePersisted(IdentifiableEntity identifiableEntity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((SourcedEntityBase)identifiableEntity);

        handleCollection(result, IdentifiableEntity.class, "credits", Credit.class);

        handleCollection(result, IdentifiableEntity.class, "extensions", Extension.class);

        handleCollection(result, IdentifiableEntity.class, "identifiers", Identifier.class);

    protected <T extends DefinedTermBase> T  handlePersisted(DefinedTermBase definedTermBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((TermBase)definedTermBase);

        handleCollection(result, DefinedTermBase.class, "media", Media.class);

        handleCollection(result, DefinedTermBase.class, "generalizationOf", DefinedTermBase.class);

        handleCollection(result, DefinedTermBase.class, "includes", DefinedTermBase.class);

        setInvisible(result, DefinedTermBase.class, "vocabulary", detache(result.getVocabulary()));

        return result;

    protected <T extends OriginalSourceBase> T  handlePersisted(OriginalSourceBase source) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((ReferencedEntityBase)source);

        handleCollection(result, OriginalSourceBase.class, "links", ExternalLink.class);

        return result;

    }

    protected <T extends LanguageStringBase> T  handlePersisted(LanguageStringBase lsBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((AnnotatableEntity)lsBase);

        result.setLanguage(detache(lsBase.getLanguage()));

        return result;

    }

    protected <T extends TeamOrPersonBase> T  handlePersisted(TeamOrPersonBase teamOrPerson) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((AgentBase)teamOrPerson);

        return result;

    }

    protected <T extends AgentBase> T  handlePersisted(AgentBase agent) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((IdentifiableMediaEntity)agent);

        result.setContact(detache(result.getContact()));

        return result;

    }

    protected <T extends TaxonBase> T  handlePersisted(TaxonBase taxonBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((IdentifiableEntity)taxonBase);

        result.setName(detache(taxonBase.getName()));

        result.setSec(detache(taxonBase.getSec()));

        return result;

    protected <T extends IdentifiableMediaEntity> T  handlePersisted(IdentifiableMediaEntity mediaEntity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((IdentifiableEntity)mediaEntity);

        handleCollection(result, IdentifiableMediaEntity.class, "media", Media.class);

        return result;

    }

    protected <T extends ReferencedEntityBase> T  handlePersisted(ReferencedEntityBase referencedEntity) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((AnnotatableEntity)referencedEntity);

        result.setCitation(detache(result.getCitation()));

        return result;

    }

    protected <T extends DescriptionBase> T  handlePersisted(DescriptionBase descriptionBase) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((IdentifiableEntity)descriptionBase);

        handleCollection(result, DescriptionBase.class, "descriptionElements", DescriptionElementBase.class);

        handleCollection(result, DescriptionBase.class, "descriptiveDataSets", DescriptiveDataSet.class);

        handleCollection(result, DescriptionBase.class, "descriptionSources", Reference.class);

    protected <T extends DescriptionElementBase> T  handlePersisted(DescriptionElementBase element) throws IllegalAccessException, InvocationTargetException, NoSuchFieldException, SecurityException, IllegalArgumentException, NoSuchMethodException {

        T result = handlePersisted((AnnotatableEntity)element);

        result.setFeature(detache(result.getFeature()));

        setInvisible(result, DescriptionElementBase.class, "inDescription", detache(result.getInDescription()));

        handleCollection(result, DescriptionElementBase.class, "sources", DescriptionElementSource.class);

    protected void cache(CdmBase cdmBase) {

       if (cdmBase instanceof User || cdmBase instanceof DefinedTermBase){

       }else{

           sessionCache.put(cdmBase.getUuid(), cdmBase);

       }

    }

    protected boolean isInCache(CdmBase cdmBase) {

    protected <T extends CdmBase> T getCached(T cdmBase) {

        T result = (T)sessionCache.get(cdmBase.getUuid());

        if (result == null){

        }

        return result;

    }

        sessionCache.clear();

    }

}

    private ITaxonNodeOutStreamPartitioner partitioner;

    private boolean concurrent = false;

    public static FauEu2CdmImportConfigurator NewInstance(ICdmDataSource source, ICdmDataSource destination) {

        return new FauEu2CdmImportConfigurator(source, destination);

    }

    protected void makeIoClassList() {

        ioClassList = new Class[]{

                FauEu2CdmTaxonNodeImport.class ,

        };

    }

        this.concurrent = concurrent;

    }

}

        extends ImportStateBase<FauEu2CdmImportConfigurator,CdmImportBase>{

    private ICdmRepository sourceRepository;

    protected FauEu2CdmImportState(FauEu2CdmImportConfigurator config) {

        super(config);

        this.sourceRepository = sourceRepository;

    }

    }

}

import eu.etaxonomy.cdm.io.common.ITaxonNodeOutStreamPartitioner;

import eu.etaxonomy.cdm.io.common.TaxonNodeOutStreamPartitioner;

import eu.etaxonomy.cdm.io.common.TaxonNodeOutStreamPartitionerConcurrent;

import eu.etaxonomy.cdm.model.taxon.TaxonNode;

/**

    @Override

    protected void doInvoke(FauEu2CdmImportState state) {

        IProgressMonitor monitor = state.getConfig().getProgressMonitor();

        FauEu2CdmImportConfigurator config = state.getConfig();

        ITaxonNodeOutStreamPartitioner partitioner = getPartitioner(state, monitor, config);

        monitor.subTask("Start partitioning");

        return partitioner;

    }

    @Override

    protected boolean doCheck(FauEu2CdmImportState state) {

    @Override

    protected boolean isIgnore(FauEu2CdmImportState state) {

    }

}