EDIT

cdmlib-model/src/main/java/eu/etaxonomy/cdm/model/ICdmUuidCacher.java -text

cdmlib-model/src/main/java/eu/etaxonomy/cdm/strategy/match/MatchStrategyConfigurator.java -text

// $Id$

/**

* Copyright (C) 2015 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.

*/

 * @date 19 Feb 2015

public interface ICdmCacher {

    public CdmBase getFromCache(CdmBase cdmBase);

    public void put(CdmBase cdmEntity);

    public CdmBase load(CdmBase cdmEntity);

    public boolean isCachable(CdmBase cdmEntity);

}

package eu.etaxonomy.cdm.model;

import java.util.UUID;

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

/**

 * @author cmathew

 *

 * Cache class for CDM Entities based on Ehcache.

 * The class manages a singleton {@link net.sf.ehcache.CacheManager} having a

 * {@link net.sf.ehcache.Cache} initialised with a default configuration.

 *

 * FIXME: This interface should actually be in an external project which also

 * includes the implemented cachers.

 *

 * @param <T>

 */

public interface ICdmUuidCacher extends ICdmCacher {

    /**

     * Puts the (Key,Value) pair of ({@link java.util.UUID}, {@link eu.etaxonomy.cdm.model.common.CdmBase}),

     * in the cache

     *

     * @param uuid

     * @param cdmEntity

     */

    public  CdmBase put(UUID uuid, CdmBase cdmEntity);

	/**

	 * Load a CDM Entity object with given UUID.

	 * This method checks the (default) cache for the entity,

	 * else retrieves the entity from the service layer.

	 *

	 * NOTE : Currently this method can only be used for CDM Term

	 * (DefinedTermBase) entities.

	 *

	 * @param uuid of CDM Entity to return

	 * @return

	 */

	public CdmBase load(UUID uuid);

	/**

	 * Get a CDM Entity object with given UUID from the (default) cache.

	 *

	 * @param uuid

	 * @return

	 */

	public CdmBase getFromCache(UUID uuid);

	/**

	 * Check if a CDM Entity with given UUID exists in the cache.

	 *

	 * @param uuid of CDM Entity to check

	 * @return true if CDM Entity with given UUID exists in the cache, o/w false

	 */

	public boolean exists(UUID uuid);

	/**

	 * Check if a CDM Entity with given UUID exists in the cache

	 * and that it is not null.

	 *

	 * @param uuid of CDM Entity to check

	 * @return true if CDM Entity with given UUID exists in the cache and that it is not null, o/w false

	 */

	public boolean existsAndIsNotNull(UUID uuid);

}

import eu.etaxonomy.cdm.model.ICdmUuidCacher;

    private static ICdmUuidCacher cacher;

    public static ICdmUuidCacher getCacher() {

	public static void setCacher(ICdmUuidCacher cacher) {

	public static <T extends DefinedTermBase> T getTermByClassAndUUID(Class<T> clazz, UUID uuid) {

	    if(cacher != null) {

	        Object obj = getCacher().load(uuid);

	        if(obj != null && obj.getClass().equals(clazz)) {

	            return (T)obj;

	        }

	    }

	    return null;

	}

// *************************** Factory MEthods ********************************/

//**************** Attributes *************************************/

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

        return termMap.get(uuid);

            termMap.put(term.getUuid(), term);

        defaultLanguage = ENGLISH();

    //FIXME: Following two methods are temporary and should be moved to more

     *

     *

     *

        if(termMap == null || termMap.isEmpty()) {

            return getTermByClassAndUUID(Language.class, uuid);

        } else {

            return termMap.get(uuid);

        }

* European Distributed Institute of Taxonomy

*

 * Most relationships are to be understood as 'is .... of': for instance

 * <i>Astragalus rhizanthus</i> Royle.

 * types if needed.

 *

	protected static Map<UUID, NameRelationshipType> termMap = null;

		if (termMap == null || termMap.isEmpty()){

		    return getTermByClassAndUUID(NameRelationshipType.class, uuid);

		} else {

		    return termMap.get(uuid);

//********************************** Constructor *********************************/

	/**

	 *

	 * 						 new name relationship type to be created

		if (this.equals(VALIDATED_BY_NAME()) ||

			return true;

		if (this.equals(BASIONYM()) ||

				this.equals(REPLACED_SYNONYM()) ||

			return true;

		if (this.equals(LATER_HOMONYM()) ||

			return true;

	 * {@link TaxonNameBase taxon name} involved in such a relationship is an

	 * Returns the {@link TaxonNameBase taxon name} as it is spelled in the original

	 * publication of the given name. The first (left) name in the relationship takes the role

	 * of the original spelling whereas the second (right) name takes the role of the

	 * {@link TaxonNameBase taxon name} involved in such a relationship is a

	 * A misspelling is always accicentally (not on purpose). Therefore misspellings are a

	 * subset of {@link #ORTHOGRAPHIC_VARIANT orthographic variants} and are complementary to

	 * {@link TaxonNameBase taxon name} involved in such a relationship is a

	 * The name corrected by an emendation has originally been used on purpose (not accidentially)

	 * Therefore emendations are a subset of {@link #ORTHOGRAPHIC_VARIANT orthographic variants} and are

	 * complementary to {@link #MISSPELLING missepllings}. An emendation is always an

	 *

	 *

	 * In contrast to the {@link #LATER_HOMONYM() later homonym} relationship the two

	 * Isonyms are handled in Article 6, Note 2 of the ICNAFP (Melbourne Code):

	 *  times perhaps by different authors, then only the earliest of these �isonyms� has

	 *  nomenclatural status. The name is always to be cited from its original

	 *

	 * Returns the "basionym" name relationship type. The first {@link TaxonNameBase taxon name}

	 * The basionym is the epithet-bringing taxon name (first taxon name

	 * taxon, the epithet of which is the same as in the second taxon name

	 * Returns the "replaced synonym" name relationship type. The first

	 *

	 *

	 *

	 *

	  return findTermByUuid(uuidLaterValidatedByName);

	 * Returns the "blocking name" name relationship type. The first

	 *

        if (termMap == null || termMap.isEmpty()){

           return getTermByClassAndUUID(Rank.class, uuid);

        } else {

            return termMap.get(uuid);

// $Id$

/**

* Copyright (C) 2007 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.cdm.strategy.match;

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

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

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

/**

 * This class defines the MatchStrategies that will be used by the ParseHandler.

 *

 * @author n.hoffmann

 * @created Jan 22, 2010

 * @version 1.0

 */

public class MatchStrategyConfigurator {

    public enum MatchStrategy {

        NonViralName,

        TeamOrPerson,

        Reference

    }

    public static IMatchStrategy getMatchStrategy(MatchStrategy strategy) throws MatchException {

        switch(strategy) {

        case NonViralName :

            return NonViralNameMatchStrategy();

        case TeamOrPerson:

            return TeamOrPersonMatchStrategy();

        case Reference :

            return ReferenceMatchStrategy();

        default :

            return null;

        }

    }

	/**

	 * <p>NonViralNameMatchStrategy</p>

	 *

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 */

	public static IMatchStrategy NonViralNameMatchStrategy() throws MatchException{

		return getDefaultNonViralNameMatchStrategy();// PreferencesUtil.getMatchStrategy(NonViralName.class);

	}

	/**

	 * <p>TeamOrPersonMatchStrategy</p>

	 *

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 */

	public static IMatchStrategy TeamOrPersonMatchStrategy() throws MatchException{

		return null;// PreferencesUtil.getMatchStrategy(TeamOrPersonBase.class);

	}

	/**

	 * <p>ReferenceMatchStrategy</p>

	 *

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 */

	public static IMatchStrategy ReferenceMatchStrategy() throws MatchException{

		return getDefaultReferenceMatchStrategy();// PreferencesUtil.getMatchStrategy(ReferenceBase.class);

	}

	/**

	 * <p>getDefaultNonViralNameMatchStrategy</p>

	 *

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 */

	public static IMatchStrategy getDefaultNonViralNameMatchStrategy() throws MatchException{

		IMatchStrategy strategy = DefaultMatchStrategy.NewInstance(NonViralName.class);

		strategy.setMatchMode("nomenclaturalReference", MatchMode.IGNORE);

		strategy.setMatchMode("combinationAuthorTeam", MatchMode.IGNORE);

		strategy.setMatchMode("exCombinationAuthorTeam", MatchMode.IGNORE);

		strategy.setMatchMode("basionymAuthorTeam", MatchMode.IGNORE);

		strategy.setMatchMode("exBasionymAuthorTeam", MatchMode.IGNORE);

		return strategy;

	}

	/**

	 * <p>getDefaultTeamOrPersonMatchStrategy</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 */

	public static IMatchStrategy getDefaultTeamOrPersonMatchStrategy() throws MatchException{

		IMatchStrategy strategy = DefaultMatchStrategy.NewInstance(TeamOrPersonBase.class);

		return strategy;

	}

	/**

	 * <p>getDefaultReferenceMatchStrategy</p>

	 *

	 * @return a {@link eu.etaxonomy.cdm.strategy.match.IMatchStrategy} object.

	 * @throws eu.etaxonomy.cdm.strategy.match.MatchException if any.

	 */

	public static IMatchStrategy getDefaultReferenceMatchStrategy() throws MatchException{

		IMatchStrategy strategy = DefaultMatchStrategy.NewInstance(Reference.class);

		strategy.setMatchMode("title", MatchMode.EQUAL);

		strategy.setMatchMode("inReference", MatchMode.IGNORE);

		return strategy;

	}

}

 * Copyright (C) 2007 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.

 */

import java.util.Set;

    private static final long serialVersionUID = 9113025682352080372L;

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

    /**

     * The event types currently implemented

     *

     * @author n.hoffmann

     * @created 25.03.2009

     * @version 1.0

     */

    public enum EventType {

        INSERT, LOAD, UPDATE, DELETE

    }

    private final CdmBase entity;

    private final EntityPersister persister;

    private final Set<CdmBase> affectedObjects;

    private final Object[] state;

    // for update only

    private Object[] oldState;

    private final Serializable id;

    protected final EventType eventType;

    /**

     * @param source

     */

    private CdmDataChangeEvent(

            CdmBase entity,

            Serializable id,

            Object[] state,

            Object[] oldState,

            EntityPersister persister,

            EventSource source,

            EventType eventType

            ) {

        super(source);

        this.entity = entity;

        this.id = id;

        this.state = state;

        this.oldState = oldState;

        this.persister = persister;

        this.eventType = eventType;

        this.affectedObjects = null;

    }

    /**

     * @param source

     */

    private CdmDataChangeEvent(

            CdmBase entity,

            Set<CdmBase> affectedObjects,

            EventType eventType

            ) {

        super(null);

        this.entity = entity;

        this.persister = null;

        this.affectedObjects = affectedObjects;

        this.state = null;

        this.oldState = null;

        this.id = null;

        this.eventType = eventType;

    }

    public CdmBase getEntity() {

        return entity;

    }

    public Serializable getId() {

        return id;

    }

    public EntityPersister getPersister() {

        return persister;

    }

    public Object[] getState() {

        return state;

    }

    public Object[] getOldState() {

        if(oldState == null){

            oldState = state;

        }

        return oldState;

    }

    public Set<CdmBase> getAffectedObjects() {

        return affectedObjects;

    }

    public EventType getEventType(){

        return eventType;

    }

    public boolean isInsert(){

        return eventType == EventType.INSERT;

    }

    public boolean isLoad(){

        return eventType == EventType.LOAD;

    }

    public boolean isUpdate(){

        return eventType == EventType.UPDATE;

    }

    public boolean isDelete(){

        return eventType == EventType.DELETE;

    }

    /**

     * @param event

     * @return

     */

    public static CdmDataChangeEvent NewInstance(AbstractEvent event) {

        CdmDataChangeEvent mediationEvent = null;

        try{

            if(event instanceof PostInsertEvent){

                PostInsertEvent postEvent = (PostInsertEvent) event;

                mediationEvent = new CdmDataChangeEvent(

                        (CdmBase)postEvent.getEntity(),

                        postEvent.getId(),

                        postEvent.getState(),

                        null,

                        postEvent.getPersister(),

                        postEvent.getSession(),

                        EventType.INSERT

                        );

            }

            if(event instanceof PostLoadEvent){

                PostLoadEvent updateEvent = (PostLoadEvent) event;

                mediationEvent = new CdmDataChangeEvent(

                        (CdmBase)updateEvent.getEntity(),

                        updateEvent.getId(),

                        null,

                        null,

                        updateEvent.getPersister(),

                        updateEvent.getSession(),

                        EventType.LOAD

                        );

            }

            if(event instanceof PostUpdateEvent){

                PostUpdateEvent updateEvent = (PostUpdateEvent) event;

                mediationEvent = new CdmDataChangeEvent(

                        (CdmBase)updateEvent.getEntity(),

                        updateEvent.getId(),

                        updateEvent.getState(),

                        updateEvent.getOldState(),

                        updateEvent.getPersister(),

                        updateEvent.getSession(),

                        EventType.UPDATE

                        );

            }

            if(event instanceof PostDeleteEvent){

                PostDeleteEvent deleteEvent = (PostDeleteEvent) event;

                mediationEvent = new CdmDataChangeEvent(

                        (CdmBase)deleteEvent.getEntity(),

                        deleteEvent.getId(),

                        deleteEvent.getDeletedState(),

                        null,

                        deleteEvent.getPersister(),

                        deleteEvent.getSession(),

                        EventType.DELETE

                        );

            }

        }catch(ClassCastException e){

            // we are only interested in CdmBase entities, we have the try/catch block in case another entity slips through

            logger.warn("tried to instantiate event for non CdmBase entity");

        }

        return mediationEvent;

    }

    public static CdmDataChangeEvent NewInstance(CdmBase entity, Set<CdmBase> affectedObjects, EventType eventType) {

        return new CdmDataChangeEvent(entity, affectedObjects, eventType);

    }