EDIT

	 * @return

	 * @throws SQLException

	 */

		boolean result = false;

		ResultSetMetaData metaData = idResultSet.getMetaData();

		int nOfIdColumns = metaData.getColumnCount();

		currentPartition++;

		currentIdListType = new int[nOfIdColumns];

		for (int col = 0; col< currentIdLists.length; col++){

/**

* Copyright (C) 2007 EDIT

* 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.

*/

import java.sql.SQLException;

import java.util.UUID;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.api.service.ITermService;

import eu.etaxonomy.cdm.api.service.IVocabularyService;

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

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

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

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

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

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

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

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

 * as it does not map to a single attribute

 * @author a.mueller

 * @since 01.03.2010

 */

public class DbImportAnnotationMapper extends DbSingleAttributeImportMapperBase<DbImportStateBase<?,?>, AnnotatableEntity> implements IDbImportMapper<DbImportStateBase<?,?>,AnnotatableEntity>{

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

	/**

	 * FIXME Warning: the annotation type creation is not yet implemented

	 * @param dbAttributeString

		AnnotationType annotationType = null;

		return new DbImportAnnotationMapper(dbAttributeString, language, annotationType);

	}

	/**

	 * * FIXME Warning: the annotation type creation is not yet implemented

	 * @param dbAttributeString

		AnnotationType annotationType = null;

		return new DbImportAnnotationMapper(dbAttributeString, language, annotationType);

	}

	/**

	 * @param dbAttributeString

	 * @param annotationType

		Language language = null;

		return NewInstance(dbAttributeString, annotationType, language);

	}

	/**

	 * @param dbAttributeString

	 * @param annotationType

	 * @return

	 */

	public static DbImportAnnotationMapper NewInstance(String dbAttributeString, AnnotationType annotationType, Language language){

		return new DbImportAnnotationMapper(dbAttributeString, language, annotationType);

	}

	private AnnotationType annotationType;

	private Language language;

		this.annotationType = annotationType;

	}

	@Override

	public void initialize(DbImportStateBase<?,?> state, Class<? extends CdmBase> destinationClass) {

		importMapperHelper.initialize(state, destinationClass);

	}

//	/**

//	 * @param service

//	 * @param state

//			//do nothing

//		}

//	}

	@Override

	public AnnotatableEntity invoke(ResultSet rs, AnnotatableEntity annotatableEntity) throws SQLException {

		if (ignore){

		String dbValue = rs.getString(getSourceAttribute());

		return doInvoke(annotatableEntity, dbValue);

	}

	@Override

	protected AnnotatableEntity doInvoke(AnnotatableEntity annotatableEntity, Object dbValue){

		String strAnnotation = (String)dbValue;

		return annotatableEntity;

	}

	/**

	 * @param service

	 * @param uuid

			//set vocabulary //TODO allow user defined vocabularies

			UUID uuidAnnotationTypeVocabulary = UUID.fromString("ca04609b-1ba0-4d31-9c2e-aa8eb2f4e62d");

			IVocabularyService vocService = currentImport.getVocabularyService();

			if (voc != null){

				voc.addTerm(annotationType);

			}else{

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.io.common.CdmSingleAttributeMapperBase#getTypeClass()

	 */

		return String.class;

	}

}

/**

* Copyright (C) 2007 EDIT

* 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.

*/

/**

 * @author a.mueller

 * @since 12.05.2009

 */

public class DbImportMapping<STATE extends DbImportStateBase, CONFIG extends IImportConfigurator> extends CdmIoMapping {

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

	private Class<? extends CdmBase> destinationClass;

	private DbImportMapping<STATE, CONFIG> secondPathMapping;

	private boolean blankToNull = false;

	public DbImportMapping(){

//		this.dbTableName = tableName;

	}

		if (!isInitialized){

			//	this.dbTableName = tableName;

			this.destinationClass = destinationClass;

			for (CdmMapperBase mapper: this.mapperList){

				if (mapper instanceof IDbImportMapper){

				}else{

					logger.warn("Mapper type " + mapper.getClass().getSimpleName() + " not yet implemented for DB import mapping");

				}

		return true;

	}

		super.addMapper(mapper);

		if (mapper instanceof DbStringMapper){

			((DbStringMapper)mapper).setBlankToNull(isBlankToNull());

		}

	}

	/**

	 * Invokes the second path mapping if one has been defined

	 * @param rs

	 */

	public boolean invoke(ResultSet rs, Set<CdmBase> objectsToSave) throws SQLException{

		return invoke(rs, objectsToSave, false);

	/**

	 * Invokes the mapping. If secondPath is true, the secondPath mapping is invoked if it exists.

	 * @param rs

			//		try {

			for (CdmMapperBase mapper : this.mapperList){

				if (mapper instanceof IDbImportMapper){

					try {

						objectToSave = dbMapper.invoke(rs, objectToSave);

					} catch (Exception e) {

						result = false;

						e.printStackTrace();

						continue;

					}

			return result;

	}

	}

		this.secondPathMapping = secondPathMapping;

	}

//		this.dbTableName = dbTableName;

//	}

//

//	protected List<CdmAttributeMapperBase> getAttributeMapperList(){

//		List<CdmAttributeMapperBase> list = this.mapperList;

//		return list;

//	}

}

/**

* Copyright (C) 2007 EDIT

* 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.

*/

/**

 * @author a.mueller

 * @since 12.05.2009

 */

public class DbImportObjectCreationMapper<ANNOTATABLE extends AnnotatableEntity, STATE extends DbImportStateBase<?,?>> extends DbImportObjectCreationMapperBase<ANNOTATABLE, STATE> {

	@SuppressWarnings("unused")

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

//******************************** FACTORY METHOD ***************************************************/

	public static DbImportObjectCreationMapper<?,?> NewInstance(IMappingImport mappingImport, String dbIdAttribute, String namespace){

	}

//******************************* ATTRIBUTES ***************************************/

	private IMappingImport<ANNOTATABLE, STATE> mappingImport;

//********************************* CONSTRUCTOR ****************************************/

	/**

	 * @param mappingImport

//************************************ METHODS *******************************************/

	@Override

	protected ANNOTATABLE doInvoke(ResultSet rs, ANNOTATABLE createdObject) throws SQLException {

		// do nothing

		return createdObject;

	}

	@Override

	protected ANNOTATABLE createObject(ResultSet rs) throws SQLException {

		ANNOTATABLE result = mappingImport.createObject(rs, importMapperHelper.getState());

		return result;

	}

}

//************************************ METHODS *******************************************/

	@Override

    public CREATE invoke(ResultSet rs, CREATE noObject) throws SQLException {

		CREATE result = createObject(rs);

				return;

			}

			IOriginalSource source;

			Object id = rs.getObject(dbIdAttribute);

			String strId = String.valueOf(id);

			String idNamespace = this.objectToCreateNamespace;

		}

	}

	/**

	 * Returns the transformer from the configuration

	 * @return

/**

* Copyright (C) 2007 EDIT

* 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.

*/

/**

 * @author a.mueller

 * @since 24.02.2010

 */

public class DbImportStringMapper extends DbSingleAttributeImportMapperBase<DbImportStateBase<?,?>, CdmBase>{

	@SuppressWarnings("unused")

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

	/**

	 * @param dbAttributString

	 * @param cdmAttributeString

		Object defaultValue = null;

		return DbImportStringMapper.NewInstance(dbAttributeString, cdmAttributeString, defaultValue, obligatory);

	}

	/**

	 * @param cdmAttributeString

	 * @param dbAttributString

		return new  DbImportStringMapper(dbAttributeString, cdmAttributeString, defaultValue, obligatory);

	}

	/**

	 * @param cdmAttributeString

	 * @param dbAttributString

		super(dbAttributeString, cdmAttributeString, defaultValue, obligatory);

	}

	@Override

	protected CdmBase doInvoke(CdmBase cdmBase, Object value) throws SQLException {

		return super.doInvoke(cdmBase, value);

	}

	@Override

	public Class getTypeClass() {

		return String.class;

	}

}

		}

		Taxon taxon = checkTaxonType(toObject, "Accepted taxon", toId);

		if (fromObject.isInstanceOf(Synonym.class)){

			SynonymType relType = SynonymType.SYNONYM_OF();

			Synonym synonym = CdmBase.deproxy(fromObject, Synonym.class);

			taxon.addSynonym(synonym, relType); //citation and micro citation not in use anymore as we do not have synonym relationships anymore

			TaxonRelationshipType type = relType;

			Taxon synonymTaxon = CdmBase.deproxy(fromObject, Taxon.class);

			synonymTaxon.addTaxonRelation(taxon, type, citation, microCitation);

	public static DbImportTaxIncludedInMapper<?> NewInstance(String dbChildAttribute, String dbChildNamespace, String dbParentAttribute, String parentNamespace, String dbAlternativeParentAttribute, String alternativeParentNamespace, String dbTreeAttribute){

		String citationNamespace = null;

		String citationAttribute = null;

	}

//******************************* ATTRIBUTES ***************************************/

//************************************ METHODS *******************************************/

	@Override

    public CdmBase invoke(ResultSet rs, CdmBase cdmBase) throws SQLException {

		STATE state = getState();

/**

 * @author a.mueller

 * @since 12.05.2009

 */

public abstract class DbSingleAttributeImportMapperBase<STATE extends DbImportStateBase<?,?>, CDM_BASE extends CdmBase> extends CdmSingleAttributeMapperBase implements IDbImportMapper<STATE, CDM_BASE>  {

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

//	private Integer precision = null;

	protected boolean obligatory = true;

	protected Method destinationMethod = null;

	protected Class<?> targetClass;

		return result;

	}

	@Override

    public CDM_BASE invoke(ResultSet rs, CDM_BASE cdmBase) throws SQLException {

		if (ignore){

/**

 * Copyright (C) 2007 EDIT

 * 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.

 */

/**

 * @author a.mueller

 * @since 12.05.2009

 */

public interface IDbImportMapper<STATE extends DbImportStateBase<?,?>, CDM_BASE extends CdmBase> {

	public void initialize(STATE state, Class<? extends CdmBase> destinationClass);

//	public void initialize(T state, String tableName);

	public CDM_BASE invoke(ResultSet rs, CDM_BASE cdmBase) throws SQLException;

}

				result.remove(setObject);

			}

		}*/

        SortedSet<T> sortedSet = getSortedSetOfTerms();

        //headSet Returns a view of the portion of this set whose elements are STRICTLY less than toElement

        result.addAll( sortedSet.headSet(otb));

		super.addTerm(termToBeAdded);

	}

		int orderInd = equalLevelTerm.orderIndex;

		termToBeAdded.orderIndex = orderInd;

		super.addTerm(termToBeAdded);

	@Transient

	private SortedSet<T> getSortedSetOfTerms(){

		for (DefinedTermBase<?> termUnproxied : terms){

            @SuppressWarnings("unchecked")

            T term = (T)CdmBase.deproxy(termUnproxied, OrderedTermBase.class);

/**

 * Interface representing all {@link Reference references} which have

 * @author a.mueller

 * @since 20.11.2018

 *

import eu.etaxonomy.cdm.model.reference.ReferenceType;

import eu.etaxonomy.cdm.validation.annotation.ReferenceCheck;

public class ReferenceCheckValidator implements ConstraintValidator<ReferenceCheck, Reference>{

    @Override

/**

* Copyright (C) 2007 EDIT

* 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.

*/

/**

 * @author a.mueller

 * @since 17.07.2008

 */

@Repository

public class OriginalSourceDaoImpl extends CdmEntityDaoBase<OriginalSourceBase> implements	IOriginalSourceDao {

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

	public OriginalSourceDaoImpl() {

	}

		Session session = getSession();

		String idInSourceString = "";

		for (String idInSource : idInSourceSet){

		Query q = session.createQuery(

                "SELECT source.idInSource, c FROM " + clazz.getSimpleName() + " AS c " +

                "INNER JOIN c.sources AS source " +

                	" AND source.idNamespace = :idNamespace"

            );

		q.setString("idNamespace", idNamespace);

		List<Object[]> list = q.list();

		for (Object[] pair : list){

			result.put((String)pair[0], (ISourceable)pair[1]);

		}

		return result;

	}

		Session session = getSession();

		Query q = session.createQuery(

                "Select c from " + clazz.getSimpleName() + " as c " +

                "inner join c.sources as source " +

                	" AND source.idNamespace = :idNamespace"

            );

		q.setString("idInSource", idInSource);

		q.setString("idNamespace", idNamespace);

		List<IdentifiableEntity> results = q.list();

		return results;

	}

		Session session = getSession();

		Criteria crit = session.createCriteria(type);

		crit.add(Restrictions.eq("idInSource", idInSource));

		}

		crit.addOrder(Order.desc("created"));

		List<OriginalSourceBase> results = crit.list();

		return results;

	}

}