EDIT

     */

    @SuppressWarnings("rawtypes")

    public void setAreaNames(List<String> namedAreas, ImportConfiguratorBase<?, ?> config, ITermService termService){

        termsList.addAll(termService.list(Country.class, 0, 0, null, null));

        if (DEBUG) {

     * @param fullName: the country's full name

     * @param app: the CDM application controller

     */

    public void setCountry(String iso, String fullName, ImportConfiguratorBase<?, ?> config, ITermService termService,

            IOccurrenceService occurrenceService){

        termsList.addAll(termService.list(Country.class, 0, 0, null, null));

        HashMap<String, UUID> matchingTerms = new HashMap<String, UUID>();

            }

            Set<OriginalSourceBase> osbSet = new HashSet<OriginalSourceBase>();

            if(issTmp2!=null) {

    //    for our new source.

    private IdentifiableSource getIdentifiableSource(Reference<?> reference, String citationDetail) {

        if (reference != null){

    @SuppressWarnings("rawtypes")

    private Institution getInstitution(String institutionCode, Abcd206ImportState state) {

        Institution institution=null;

        try {

            institutions = getAgentService().list(Institution.class, null, null, null, null);

        } catch (Exception e) {

            logger.warn(e);

        }

        if (institutions.size() > 0 && state.getConfig().isReUseExistingMetadata()) {

                try{

                    if (institut.getCode().equalsIgnoreCase(institutionCode)) {

                        institution=institut;

            // create institution

            institution = Institution.NewInstance();

            institution.setCode(institutionCode);

        }

        save(institution, state);

        return institution;

        Map<String,OriginalSourceBase<?>> sourceMap = new HashMap<String, OriginalSourceBase<?>>();

        Set<OriginalSourceBase> osbSet = new HashSet<OriginalSourceBase>();

        if(issTmp2!=null) {

    }

    private Feature getFeature(String featureName, Abcd206ImportState state){

        Feature currentFeature=null;

            if (tmpF.equalsIgnoreCase(featureName)) {

                currentFeature=(Feature)feature;

            }

import eu.etaxonomy.cdm.model.agent.AgentBase;

import eu.etaxonomy.cdm.model.agent.Person;

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

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

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

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

    @SuppressWarnings("rawtypes")

    private Feature getFeatureObjectFromString(String featureName) {

        logger.info("getFeatureObjectFromString");

        Feature currentFeature=null;

            if (tmpF.equalsIgnoreCase(featureName)) {

                //                System.out.println("currentFeatureFromList "+currentFeature.getUuid());

            }

        }

    @SuppressWarnings("rawtypes")

    private Feature getNotMarkedUpFeatureObject() {

        logger.info("getNotMarkedUpFeatureObject");

        Feature currentFeature =null;

            if (tmpF.equalsIgnoreCase(notMarkedUp)) {

            }

        }

        if (currentFeature == null) {

                }

            }

            if (lsid !=null){

                LSID currentlsid=null;

                    currentlsid = t.getLsid();

                    if (currentlsid !=null){

                        if (currentlsid.getLsid().equals(lsid.getLsid())){

	private String sql(String thisTable, String thisField, String foreignTable){

		sql = String.format(sql, thisTable, thisTable, thisField, foreignTable);

		return sql;

	}

     * @return

     * @throws DataAccessException

     */

    /**

     * Returns a sublist of CdmBase instances stored in the database. A maximum

     * @return

     * @throws DataAccessException

     */

    /**

     * Returns a sublist of objects matching the grouping projections supplied using the groups parameter

    }

    @Override

        Criteria criteria = null;

        if(clazz == null) {

            criteria = getSession().createCriteria(type);

        addOrder(criteria,orderHints);

        defaultBeanInitializer.initializeAll(results, propertyPaths);

        return results;

    }

        return list(type,limit,start,orderHints,null);

    }

    @Override

        return list(type,limit,start,null,null);

    }

	}

	@Override

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

			return super.list(type,limit, start);

	}

	@Override

		AuditEvent auditEvent = getAuditEventFromContext();

		if(auditEvent.equals(AuditEvent.CURRENT_VIEW)) {

			return super.list(clazz, limit, start, orderHints, propertyPaths);

			  query.setFirstResult(start);

			}

			defaultBeanInitializer.initializeAll(result, propertyPaths);

		    return result;

		}

        return persistentObject.getUuid();

    }

    @Override

    public ZoologicalName findZoologicalNameByUUID(UUID uuid){

import org.hibernate.criterion.Criterion;

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

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

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

	 */

	public Integer countByName(Class<? extends TaxonNameBase> clazz, String queryString, MatchMode matchmode, List<Criterion> criteria);

	public ZoologicalName findZoologicalNameByUUID(UUID uuid);

}

    @Test

    @DataSet("AgentDaoImplTest.testExists.xml")

    public void testListPeople() {

        Assert.assertNotNull("list() should return a list",result);

        Assert.assertEquals("list() should return four agents in the current view", result.size(),4);

    }

    @DataSet("AgentDaoImplTest.testExists.xml")

    public void testListPeopleInPreviousView() {

        AuditEventContextHolder.getContext().setAuditEvent(previousAuditEvent);

        Assert.assertNotNull("list() should return a list",result);

        Assert.assertEquals("list() should return five agents in the current view",result.size(),5);

    }

		 List<String> propertyPaths = new ArrayList<String>();

		 propertyPaths.add("representations");

		 propertyPaths.add("representations.language");

		 assertTrue(Hibernate.isInitialized(extensionTypes.get(0).getRepresentations()));

    @Test

    @DataSet

    public void testListAllTaxa() {

        assertNotNull("list should return a List",taxa);

        assertEquals("list should return 33 taxa",33, taxa.size());

    }

		final BeanItemContainer<RedlistDTO> redListContainer = new BeanItemContainer<RedlistDTO>(RedlistDTO.class);

		//TODO: Make use of paging

		}

		setContainerDataSource(redListContainer);

//		conversationHolder.bind();

		final BeanItemContainer<RedlistDTO> redListContainer = new BeanItemContainer<RedlistDTO>(RedlistDTO.class);

		//TODO: Make use of paging

		}

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

import eu.etaxonomy.cdm.model.location.NamedArea;

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

import eu.etaxonomy.cdm.remote.dto.redlist.RedlistDTO;

import eu.etaxonomy.cdm.remote.vaadin.components.HorizontalToolbar;

import eu.etaxonomy.cdm.remote.vaadin.components.TaxonTableDTO;

	 //------------------------------------Example Data Creation------------------------------------------//

	//---------------------------------------------------------------------------------------------------//

	private void createExampleData(){

			TaxonDescription td = getTaxonDescription(taxon, false, true);

			NamedArea na = NamedArea.NewInstance();//0a9727d2-8d1f-4a88-ad4c-d6ef4ebc112a

			na = (NamedArea) termService.load(UUID.fromString("cbe7ce69-2952-4309-85dd-0d7d4a4830a1"));

	}

	private void deleteExampleData(){

		while(taxonIterator.hasNext()){

			TaxonDescription td = getTaxonDescription(taxon, false, false);

			Iterator<DescriptionElementBase> descriptionIterator = td.getElements().iterator();

			while(descriptionIterator.hasNext()){

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.api.service.pager.Pager;

import eu.etaxonomy.cdm.api.service.pager.impl.DefaultPagerImpl;

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

import eu.etaxonomy.cdm.model.agent.Address;

import eu.etaxonomy.cdm.model.agent.Person;

import eu.etaxonomy.cdm.model.agent.Team;

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

import eu.etaxonomy.cdm.persistence.dao.agent.IAgentDao;

import eu.etaxonomy.cdm.strategy.cache.common.IIdentifiableEntityCacheStrategy;

     * @return

     */

    //TODO refactor to public <S extends T> List<T> list(Class<S> type, Integer limit, Integer start, List<OrderHint> orderHints, List<String> propertyPaths);

    /**

     * Finds the cdm entity specified by the <code>uuid</code> parameter and

     * @param propertyPaths properties to be initialized

     * @return a pager of objects of type <T>

     */

    /**

     * Re-read the state of the given instance from the underlying database.

public interface ITaxonService extends IIdentifiableEntityService<TaxonBase>{

    /**

     * Computes all Taxon instances that do not have a taxonomic parent.

     * @param sec The concept reference that the taxon belongs to

	}

	@Transactional(readOnly = false)  //TODO check transactional behaviour, e.g. what happens with the session if count is very large 

		if (stepSize == null){

			stepSize = UPDATE_TITLE_CACHE_DEFAULT_STEP_SIZE;

		}

			Map<Class<? extends CdmBase>, AutoPropertyInitializer<CdmBase>> oldAutoInit = switchOfAutoinitializer();

			switchOnOldAutoInitializer(oldAutoInit);

			List<T> entitiesToUpdate = new ArrayList<T>();

import org.apache.log4j.Logger;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Service;

import org.springframework.transaction.annotation.Transactional;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

    @Override

    @Transactional(readOnly = true)

        return dao.list(type,limit, start, orderHints,propertyPaths);

    }

    @Override

    @Transactional(readOnly = true)

        Integer numberOfResults = dao.count(type);

        pageNumber = pageNumber == null ? 0 : pageNumber;

        if(numberOfResults > 0) { // no point checking again  //TODO use AbstractPagerImpl.hasResultsInRange(numberOfResults, pageNumber, pageSize)

            Integer start = pageSize == null ? 0 : pageSize * pageNumber;

            results = dao.list(type, pageSize, start, orderHints,propertyPaths);

        }

    }

    @Override

        return dao.getTaxaByName(name, sec);

    }

    /**

     * FIXME Candidate for harmonization

     * merge with getRootTaxa(Reference sec, ..., ...)

        return dao.getRootTaxa(sec, cdmFetch, onlyWithChildren, false);

    }

    @Override

    public List<Taxon> getRootTaxa(Rank rank, Reference sec, boolean onlyWithChildren,boolean withMisapplications, List<String> propertyPaths) {

        return dao.getRootTaxa(rank, sec, null, onlyWithChildren, withMisapplications, propertyPaths);

    }

    @Override

    public List<RelationshipBase> getAllRelationships(int limit, int start){

        return dao.getAllRelationships(limit, start);

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

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

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

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

/**

        List<DefinedTermBase> superAreaList = termService.find(superAreaUuids);

        // visit all accepted taxa

        int pageIndex = 0;

        boolean isLastPage = false;

        while (!isLastPage) {

            isLastPage = taxonPager.getRecords().size() < batchSize;

            // iterate over the taxa and accumulate areas

                if(logger.isDebugEnabled()){

                }

                TaxonDescription description = findComputedDescription(taxon, doClearDescriptions);

                List<Distribution> distributions = distributionsFor(taxon);

import java.util.UUID;

import org.apache.log4j.Logger;

import org.junit.Assert;

import org.junit.Test;

import org.unitils.dbunit.annotation.DataSet;

import eu.etaxonomy.cdm.api.service.config.SynonymDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.TaxonDeletionConfigurator;

import eu.etaxonomy.cdm.api.service.config.TaxonNodeDeletionConfigurator.ChildHandling;

import eu.etaxonomy.cdm.api.service.exception.HomotypicalGroupChangeException;

import eu.etaxonomy.cdm.datagenerator.TaxonGenerator;

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

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

        Classification tree = classificationService.find(classificationUuid);

        UUID taxonUuid = UUID.fromString("bc09aca6-06fd-4905-b1e7-cbf7cc65d783");

        TaxonBase<?> taxonBase =  service.find(taxonUuid);

        assertEquals("Number of synonyms should be 2",2,synonyms.size());

        Taxon taxon = (Taxon)taxonBase;

import eu.etaxonomy.cdm.database.DatabaseTypeEnum;

import eu.etaxonomy.cdm.database.ICdmDataSource;

import eu.etaxonomy.cdm.model.common.init.TermNotFoundException;

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

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

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

		IDescriptionService service = applicationController.getDescriptionService();

		// get all taxon descriptions

		int countTaxonDescriptions = 0;

			// filter image galleries with more than one element

			if(description.isImageGallery() && description.getElements().size() > 1){

				countTaxonDescriptions++;

				logger.warn("Found image gallery with mulitple TextData: " + description.getElements().size());

				TextData newDescriptionElement = TextData.NewInstance(Feature.IMAGE());

				Set<DescriptionElementBase> elementsToRemove = new HashSet<DescriptionElementBase>();

				// consolidate media from all elements into a new element

					List<Media> medias = element.getMedia();

					for(Media media : medias){

				// remove old elements

				for(DescriptionElementBase element : elementsToRemove){

				}				

				// add the new element

			}

		}