EDIT

/**

 * Copyright (C) 2008 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.io.jaxb;

import java.io.ByteArrayOutputStream;

import java.io.File;

import java.io.FileNotFoundException;

import java.io.FileOutputStream;

import java.io.OutputStreamWriter;

import java.io.PrintWriter;

import java.io.UnsupportedEncodingException;

import java.net.URI;

import java.util.ArrayList;

import java.util.List;

import javax.xml.transform.stream.StreamResult;

import org.apache.log4j.Logger;

import org.springframework.stereotype.Component;

import org.springframework.transaction.TransactionStatus;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

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

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

import eu.etaxonomy.cdm.io.common.mapping.out.IExportTransformer;

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

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

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

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

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

import eu.etaxonomy.cdm.model.occurrence.SpecimenOrObservationBase;

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

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

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

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

/**

 * @author a.babadshanjan

 * @created 25.09.2008

 * @version 1.0

 */

@Component

public class JaxbExport extends CdmExportBase<JaxbExportConfigurator, JaxbExportState, IExportTransformer> implements ICdmExport<JaxbExportConfigurator, JaxbExportState> {

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

    private DataSet dataSet;

    //	/**

    //	 *

    //	 */

    //	public JaxbExport() {

    //		super();

    //		this.ioName = this.getClass().getSimpleName();

    //	}

    /** Retrieves data from a CDM DB and serializes them CDM to XML.

     * Starts with root taxa and traverses the classification to retrieve children taxa, synonyms and relationships.

     * Taxa that are not part of the classification are not found.

     *

     * @param exImpConfig

     * @param dbname

     * @param filename

     */

    //	@Override

    //	protected boolean doInvoke(IExportConfigurator config,

    //			Map<String, MapWrapper<? extends CdmBase>> stores) {

    @Override

    protected void doInvoke(JaxbExportState state) {

        JaxbExportConfigurator jaxbExpConfig = (JaxbExportConfigurator)state.getConfig();

        //		String dbname = jaxbExpConfig.getSource().getName();

        URI uri = jaxbExpConfig.getDestination();

        //		logger.info("Serializing DB " + dbname + " to file " + fileName);

        //		logger.debug("DbSchemaValidation = " + jaxbExpConfig.getDbSchemaValidation());

        TransactionStatus txStatus = null;

        txStatus = startTransaction(true);

        dataSet = new DataSet();

        // get data from DB

        try {

            logger.info("Retrieving data from DB");

            retrieveData(jaxbExpConfig, dataSet);

        } catch (Exception e) {

            logger.error("Error retrieving data");

            e.printStackTrace();

        }

        logger.info("All data retrieved");

        try {

            switch(jaxbExpConfig.getTarget()) {

            case FILE:

                writeToFile(new File(uri), dataSet);

                break;

            case EXPORT_DATA:

                CdmDocumentBuilder cdmDocumentBuilder = new CdmDocumentBuilder();

                exportStream = new ByteArrayOutputStream();

                cdmDocumentBuilder.marshal(dataSet, new StreamResult(exportStream));

                break;

            default:

                break;

            }

        } catch (Exception e) {

            logger.error("Marshalling error");

            e.printStackTrace();

        }

        commitTransaction(txStatus);

        return;

    }

    public static void writeToFile(File file, DataSet dataSet) throws UnsupportedEncodingException, FileNotFoundException {

        CdmDocumentBuilder cdmDocumentBuilder = new CdmDocumentBuilder();

        PrintWriter writer = new PrintWriter(new OutputStreamWriter(new FileOutputStream(file), "UTF8"), true);

        cdmDocumentBuilder.marshal(dataSet, writer);

        // TODO: Split into one file per data set member to see whether performance improves?

        logger.info("XML file written");

        logger.info("Filename is: " + file.getAbsolutePath());

    }

    private void retrieveData (IExportConfigurator config, DataSet dataSet) {

        JaxbExportConfigurator jaxbExpConfig = (JaxbExportConfigurator)config;

        final int MAX_ROWS = 50000;

        int numberOfRows = jaxbExpConfig.getMaxRows();

        int agentRows = numberOfRows;

        int definedTermBaseRows = numberOfRows;

        int referenceBaseRows = numberOfRows;

        int taxonNameBaseRows = numberOfRows;

        int taxonBaseRows = numberOfRows;

        int taxonNodeRows = numberOfRows;

        int relationshipRows = numberOfRows;

        int occurrencesRows = numberOfRows;

        int mediaRows = numberOfRows;

        int featureDataRows = numberOfRows;

        int classificationDataRows = numberOfRows;

        int languageDataRows = numberOfRows;

        int termVocabularyRows = numberOfRows;

        int homotypicalGroupRows = numberOfRows;

        int UserRows= numberOfRows;

        if (jaxbExpConfig.isDoUsers() == true) {

            if (UserRows == 0) { UserRows = MAX_ROWS; }

            logger.info("# User");

            List<User> users = getUserService().list(null, UserRows, 0, null, null);

            for (User user: users){

                dataSet.addUser( (User)HibernateProxyHelper.deproxy(user));

            }

        }

        if (jaxbExpConfig.isDoTermVocabularies() == true) {

            if (termVocabularyRows == 0) { termVocabularyRows = MAX_ROWS; }

            logger.info("# TermVocabulary");

            dataSet.setTermVocabularies((List)getVocabularyService().list(null,termVocabularyRows, 0, null, null));

        }

        //		if (jaxbExpConfig.isDoLanguageData() == true) {

        //			if (languageDataRows == 0) { languageDataRows = MAX_ROWS; }

        //			logger.info("# Representation, Language String");

        //			dataSet.setLanguageData(getTermService().getAllRepresentations(MAX_ROWS, 0));

        //TODO!!!

        dataSet.setLanguageStrings(getTermService().getAllLanguageStrings(MAX_ROWS, 0));

        //		}

        if (jaxbExpConfig.isDoTerms() == true) {

            if (definedTermBaseRows == 0) { definedTermBaseRows = getTermService().count(DefinedTermBase.class); }

            logger.info("# DefinedTermBase: " + definedTermBaseRows);

            dataSet.setTerms(getTermService().list(null,definedTermBaseRows, 0,null,null));

        }

        if (jaxbExpConfig.isDoAuthors() == true) {

            if (agentRows == 0) { agentRows = getAgentService().count(AgentBase.class); }

            logger.info("# Agents: " + agentRows);

            //logger.info("    # Team: " + appCtr.getAgentService().count(Team.class));

            dataSet.setAgents(getAgentService().list(null,agentRows, 0,null,null));

        }

        if (jaxbExpConfig.getDoReferences() != IExportConfigurator.DO_REFERENCES.NONE) {

            if (referenceBaseRows == 0) { referenceBaseRows = getReferenceService().count(Reference.class); }

            logger.info("# Reference: " + referenceBaseRows);

            dataSet.setReferences(getReferenceService().list(null,referenceBaseRows, 0,null,null));

        }

        if (jaxbExpConfig.isDoHomotypicalGroups() == true) {

            if (homotypicalGroupRows == 0) { homotypicalGroupRows = MAX_ROWS; }

            logger.info("# Homotypical Groups");

            dataSet.setHomotypicalGroups(getNameService().getAllHomotypicalGroups(homotypicalGroupRows, 0));

        }

        if (jaxbExpConfig.isDoTaxonNames() == true) {

            if (taxonNameBaseRows == 0) { taxonNameBaseRows = getNameService().count(TaxonNameBase.class); }

            logger.info("# TaxonNameBase: " + taxonNameBaseRows);

            //logger.info("    # Taxon: " + getNameService().count(BotanicalName.class));

            dataSet.setTaxonomicNames(getNameService().list(null,taxonNameBaseRows, 0,null,null));

        }

        if (jaxbExpConfig.isDoTaxa() == true) {

            if (taxonBaseRows == 0) { taxonBaseRows = getTaxonService().count(TaxonBase.class); }

            logger.info("# TaxonBase: " + taxonBaseRows);

            //			dataSet.setTaxa(new ArrayList<Taxon>());

            //			dataSet.setSynonyms(new ArrayList<Synonym>());

            List<TaxonBase> tb = getTaxonService().list(null,taxonBaseRows, 0,null,null);

            for (TaxonBase taxonBase : tb) {

                dataSet.addTaxonBase((TaxonBase)HibernateProxyHelper.deproxy(taxonBase));

            }

        }

        // TODO:

        // retrieve taxa and synonyms separately

        // need correct count for taxa and synonyms

        //		if (taxonBaseRows == 0) { taxonBaseRows = getTaxonService().count(TaxonBase.class); }

        //		logger.info("# Synonym: " + taxonBaseRows);

        //		dataSet.setSynonyms(new ArrayList<Synonym>());

        //		dataSet.setSynonyms(getTaxonService().getAllSynonyms(taxonBaseRows, 0));

        //		if (jaxbExpConfig.isDoRelTaxa() == true) {

        //			if (relationshipRows == 0) { relationshipRows = MAX_ROWS; }

        //			logger.info("# Relationships");

        //			List<RelationshipBase> relationList = getTaxonService().getAllRelationships(relationshipRows, 0);

        //			Set<RelationshipBase> relationSet = new HashSet<RelationshipBase>(relationList);

        //			dataSet.setRelationships(relationSet);

        //		}

        if (jaxbExpConfig.isDoOccurrence() == true) {

            if (occurrencesRows == 0) { occurrencesRows = getOccurrenceService().count(SpecimenOrObservationBase.class); }

            logger.info("# SpecimenOrObservationBase: " + occurrencesRows);

            List<SpecimenOrObservationBase> occurrenceList = getOccurrenceService().list(null,occurrencesRows, 0,null,null);

            /*List<SpecimenOrObservationBase> noProxyList = new ArrayList<SpecimenOrObservationBase>();

			for (SpecimenOrObservationBase specimen : occurrenceList){

				specimen = (SpecimenOrObservationBase)HibernateProxyHelper.deproxy(specimen);

				noProxyList.add(specimen);

			}*/

            dataSet.setOccurrences(occurrenceList);

        }

        if (jaxbExpConfig.isDoTypeDesignations() == true) {

            logger.info("# TypeDesignations");

            dataSet.addTypeDesignations(getNameService().getAllTypeDesignations(MAX_ROWS, 0));

        }

        if (jaxbExpConfig.isDoMedia() == true) {

            if (mediaRows == 0) { mediaRows = MAX_ROWS; }

            logger.info("# Media");

            dataSet.setMedia(getMediaService().list(null,mediaRows, 0,null,null));

            //			dataSet.addMedia(getMediaService().getAllMediaRepresentations(mediaRows, 0));

            //			dataSet.addMedia(getMediaService().getAllMediaRepresentationParts(mediaRows, 0));

        }

        if (jaxbExpConfig.isDoFeatureData() == true) {

            if (featureDataRows == 0) { featureDataRows = MAX_ROWS; }

            logger.info("# Feature Tree, Feature Node");

            List<FeatureTree> featureTrees = new ArrayList<FeatureTree>();

            featureTrees= getFeatureTreeService().list(null,featureDataRows, 0, null, null);

            List<FeatureTree> taxTreesdeproxy = new ArrayList<FeatureTree>();

            for (FeatureTree featureTree : featureTrees){

                HibernateProxyHelper.deproxy(featureTree);

                taxTreesdeproxy.add(featureTree);

            }

            dataSet.setFeatureTrees(getFeatureTreeService().list(null,null,null,null,null));

        }

        if (jaxbExpConfig.isDoClassificationData() == true) {

            if (classificationDataRows == 0) { classificationDataRows = MAX_ROWS; }

            logger.info("# Classification");

            List<Classification> taxTrees = new ArrayList<Classification>();

            taxTrees= getClassificationService().list(null,classificationDataRows, 0, null, null);

            List<Classification> taxTreesdeproxy = new ArrayList<Classification>();

            for (Classification taxTree : taxTrees){

                HibernateProxyHelper.deproxy(taxTree);

                taxTreesdeproxy.add(taxTree);

            }

            List<TaxonNode> taxNodes = new ArrayList<TaxonNode>();

            taxNodes= getClassificationService().getAllNodes();

            List<TaxonNode> taxNodesdeproxy = new ArrayList<TaxonNode>();

            for (TaxonNode taxNode : taxNodes){

                HibernateProxyHelper.deproxy(taxNode);

                taxNodesdeproxy.add(taxNode);

            }

            dataSet.setTaxonNodes(taxNodesdeproxy);

            dataSet.setClassifications(taxTreesdeproxy );

        }

        //TODO: FIXME!!!!!

        dataSet.setLanguageStrings(null);

    }

    @Override

    protected boolean doCheck(JaxbExportState state) {

        boolean result = true;

        logger.warn("No check implemented for Jaxb export");

        return result;

    }

    @Override

    protected boolean isIgnore(JaxbExportState state) {

        return false;

    }

}

import org.hibernate.proxy.LazyInitializer;

		/**

		 * Unwrap the target instance from the proxy.

		 */

		public static Object deproxy(Object object){

			if(object instanceof HibernateProxy) {

				LazyInitializer lazyInitializer = ((HibernateProxy)object).getHibernateLazyInitializer();

				return lazyInitializer.getImplementation();

			} else {

				return object;

			}

		}

// $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 java.lang.annotation.Annotation;

import java.lang.reflect.Field;

import java.lang.reflect.GenericDeclaration;

import java.lang.reflect.ParameterizedType;

import java.lang.reflect.Type;

import java.lang.reflect.TypeVariable;

import java.net.URI;

import java.util.ArrayList;

import java.util.Collection;

import java.util.HashMap;

import java.util.List;

import java.util.Map;

import java.util.Set;

import java.util.UUID;

import org.apache.commons.lang.StringUtils;

import org.apache.log4j.Logger;

import eu.etaxonomy.cdm.common.CdmUtils;

import eu.etaxonomy.cdm.common.DOI;

import eu.etaxonomy.cdm.common.DoubleResult;

import eu.etaxonomy.cdm.hibernate.HibernateProxyHelper;

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

import eu.etaxonomy.cdm.strategy.StrategyBase;

import eu.etaxonomy.cdm.strategy.match.Match.ReplaceMode;

/**

 * @author a.mueller

 * @created 06.08.2009

 * @version 1.0

 */

public class DefaultMatchStrategy extends StrategyBase implements IMatchStrategy {

	private static final long serialVersionUID = 5045874493910155162L;

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

	final static UUID uuid = UUID.fromString("69467b70-07ec-43a6-b779-3ec8d013837b");

	public static DefaultMatchStrategy NewInstance(Class<? extends IMatchable> matchClazz){

		return new DefaultMatchStrategy(matchClazz);

	}

//	protected Map<String, MatchMode> matchModeMap = new HashMap<String, MatchMode>();

	protected MatchMode defaultMatchMode = MatchMode.EQUAL;

	protected MatchMode defaultCollectionMatchMode = MatchMode.IGNORE;

	protected MatchMode defaultMatchMatchMode = MatchMode.MATCH;

	protected Class<? extends IMatchable> matchClass;

	protected Map<String, Field> matchFields;

	protected Matching matching = new Matching();

	protected DefaultMatchStrategy(Class<? extends IMatchable> matchClazz) {

		super();

		if (matchClazz == null){

			throw new IllegalArgumentException("Match class must not be null");

		}

		this.matchClass = matchClazz;

		initMapping();

	}

	/**

	 * @return the merge class

	 */

	public Class<? extends IMatchable> getMatchClass() {

		return matchClass;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.strategy.StrategyBase#getUuid()

	 */

	@Override

	protected UUID getUuid() {

		return uuid;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.strategy.match.IMatchStrategy#getMatching()

	 */

	public Matching getMatching() {

		return matching;

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.strategy.match.IMatchStrategy#setMatchMode(java.lang.String, eu.etaxonomy.cdm.strategy.match.MatchMode)

	 */

	public void setMatchMode(String propertyName, MatchMode matchMode)

			throws MatchException {

		if (matchFields.containsKey(propertyName)){

			FieldMatcher fieldMatcher = FieldMatcher.NewInstance(matchFields.get(propertyName), matchMode);

			matching.setFieldMatcher(fieldMatcher);

		}else{

			throw new MatchException("The class " + matchClass.getName() + " does not contain a field named " + propertyName);

		}

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.strategy.match.IMatchStrategy#getMatchMode(java.lang.String)

	 */

	public MatchMode getMatchMode(String propertyName) {

		FieldMatcher fieldMatcher = matching.getFieldMatcher(propertyName);

		return fieldMatcher == null ? defaultMatchMode : fieldMatcher.getMatchMode();

	}

	/* (non-Javadoc)

	 * @see eu.etaxonomy.cdm.strategy.match.IMatchStrategy#invoke(eu.etaxonomy.cdm.strategy.match.IMatchable, eu.etaxonomy.cdm.strategy.match.IMatchable)

	 */

	public <T extends IMatchable> boolean invoke(T matchFirst, T matchSecond)

			throws MatchException {

		boolean result = true;

		if (matchFirst == null || matchSecond == null){

			return false;

		}else if (matchFirst == matchSecond){

			return true;

		}else if (matchFirst.getClass() != matchSecond.getClass()){

			matchFirst = (T) HibernateProxyHelper.deproxy(matchFirst);

			matchSecond = (T) HibernateProxyHelper.deproxy(matchSecond);

			if (matchFirst.getClass() != matchSecond.getClass()){

				return false;

			}

		}

		matching.deleteTemporaryMatchers(); //just in case they are not yet deleted during last invoke

		if (! matchClass.isAssignableFrom(matchFirst.getClass()) ){

			throw new MatchException("Match object are of different type than the match class (" + matchClass + ") this match strategy was created with");

		}else if (matchClass != matchFirst.getClass()){

			initializeSubclass(matchFirst.getClass());

		}

		try {

			result = invokeChecked(matchFirst, matchSecond, result);

		}catch (MatchException e) {

			throw e;

		}finally{

			matching.deleteTemporaryMatchers();

		}

		return result;

	}

	/**

	 * @param class1

	 */

	private void initializeSubclass(Class<? extends IMatchable> instanceClass) {

		Map<String, Field> subClassFields = CdmUtils.getAllFields(instanceClass, matchClass, false, false, true, false);

		for (Field field: subClassFields.values()){

			initField(field, true);

		}

	}

	/**

	 * @param <T>

	 * @param matchFirst

	 * @param matchSecond

	 * @param result

	 * @return

	 * @throws MatchException

	 */

	private <T extends IMatchable> boolean invokeChecked(T matchFirst, T matchSecond,

			boolean result) throws MatchException {

		//matchFirst != matchSecond != null

		try {

			Map<String, List<MatchMode>> replaceMatchers = new HashMap<String, List<MatchMode>>();

			for (CacheMatcher cacheMatcher: matching.getCacheMatchers()){

				Field protectedField = cacheMatcher.getProtectedField(matching);

				boolean protected1 = protectedField.getBoolean(matchFirst);

				boolean protected2 = protectedField.getBoolean(matchFirst);

				if (protected1 != protected2){

					return false;

				}else if (protected1 == false){

					//ignore

				}else{

					String cache1 = (String)cacheMatcher.getField().get(matchFirst);

					String cache2 = (String)cacheMatcher.getField().get(matchSecond);

					result = cacheMatcher.getMatchMode().matches(cache1, cache2, null);

					if (result == false){

						return false;

					}

					List<DoubleResult<String, MatchMode>> replacementModes = cacheMatcher.getReplaceMatchModes(matching);

					for (DoubleResult<String, MatchMode> replacementMode: replacementModes ){

						String propertyName = replacementMode.getFirstResult();

						List<MatchMode> replaceMatcherList = replaceMatchers.get(propertyName);

						if (replaceMatcherList == null){

							replaceMatcherList = new ArrayList<MatchMode>();

							replaceMatchers.put(propertyName, replaceMatcherList);

						}

						replaceMatcherList.add(replacementMode.getSecondResult());

					}

				}

			}

			for (FieldMatcher fieldMatcher : matching.getFieldMatchers(true)){

				Field field = fieldMatcher.getField();

				List<MatchMode> replaceModeList = replaceMatchers.get(fieldMatcher.getPropertyName());

				if (replaceModeList == null){

					replaceModeList = new ArrayList<MatchMode>();

				}

				Class<?> fieldType = field.getType();

				logger.debug(field.getName() + ": ");

				if (isPrimitive(fieldType)){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if (fieldType == String.class ){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if (fieldType == Integer.class ){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(isUserType(fieldType)){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(fieldType == UUID.class){

					//result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(fieldType == URI.class){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(fieldType == DOI.class){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(isSingleCdmBaseObject(fieldType)){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if (isCollection(fieldType)){

					result &= matchCollectionField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(fieldType.isInterface()){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else if(fieldType.isEnum()){

					result &= matchPrimitiveField(matchFirst, matchSecond, fieldMatcher, replaceModeList);

				}else{

					throw new RuntimeException("Unknown Object type for matching: " + fieldType);

				}

//				if (result == false){

//					return result;

//				}

			}

		} catch (Exception e) {

			throw new MatchException("Match Exception in invoke", e);

		}

		return result;

	}

	/**

	 * @throws Exception 

	 * 

	 */

	private <T extends IMatchable> boolean matchPrimitiveField(T matchFirst, T matchSecond, FieldMatcher fieldMatcher, List<MatchMode> replaceModeList) throws Exception {

		Field field = fieldMatcher.getField();

		Object value1 = checkEmpty(field.get(matchFirst));

		Object value2 = checkEmpty(field.get(matchSecond));

		IMatchStrategy matchStrategy = fieldMatcher.getMatchStrategy();

		boolean result = fieldMatcher.getMatchMode().matches(value1, value2, matchStrategy);

		for (MatchMode replaceMode : replaceModeList){

			if (result == true){

				break; 

			}

			result |= replaceMode.matches(value1, value2, null);

		}

		logger.debug(fieldMatcher.getMatchMode() + ", " + field.getType().getName()+ ": " + result);

		return result;

	}

	/**

	 * @throws Exception 

	 * 

	 */

	private <T extends IMatchable> boolean matchCollectionField(T matchFirst, T matchSecond, FieldMatcher fieldMatcher, List<MatchMode> replaceModeList) throws Exception {

		boolean result;

		Field field = fieldMatcher.getField();

		Collection<?> value1 = (Collection)field.get(matchFirst);

		Collection<?> value2 = (Collection)field.get(matchSecond);

		MatchMode matchMode = fieldMatcher.getMatchMode();

		Class<?> fieldType = fieldMatcher.getField().getType();

		IMatchStrategy matchStrategy = fieldMatcher.getMatchStrategy();

		if (matchMode.isMatch()){

			Class collectionType = getTypeOfSet(field);

			if (! IMatchable.class.isAssignableFrom(collectionType)){

				//TODO

				return fieldMatcher.getMatchMode().matches(value1, value2, matchStrategy);	

			}

			if (matchStrategy == null){

				matchStrategy = DefaultMatchStrategy.NewInstance(collectionType);

			}

			if (Set.class.isAssignableFrom(fieldType)){

				result = matchSet(value1, value2, matchStrategy);

			}else if (List.class.isAssignableFrom(fieldType)){

				result = matchList(value1, value2, matchStrategy);

			}else{

				throw new MatchException("Collection type not yet supported: " + fieldType);

			}

		}else{

			result = fieldMatcher.getMatchMode().matches(value1, value2, matchStrategy);

		}

		//cache replace modes

		for (MatchMode replaceMode : replaceModeList){

			if (result == true){

				break; 

			}

			result |= replaceMode.matches(value1, value2, null);

		}

		logger.debug(fieldMatcher.getMatchMode() + ", " + field.getType().getName()+ ": " + result);

		return result;

	}

	/**

	 * @param object

	 * @return

	 */

	private Object checkEmpty(Object object) {

		if (object instanceof String){

			if (StringUtils.isBlank((String)object)){

				return null;

			}

		}

		return HibernateProxyHelper.deproxy(object);

	}

	/**

	 * @param value1

	 * @param matchStrategy

	 * @return

	 * @throws MatchException

	 */

	private boolean matchSet(Collection value1, Collection value2, IMatchStrategy matchStrategy)

			throws MatchException {

		boolean result;

		Set<IMatchable> set1 = (Set<IMatchable>)value1;

		Set<IMatchable> set2 = (Set<IMatchable>)value2;

		if (set1.size()!= set2.size()){

			return false;

		}

		result = true;

		for (IMatchable setItem1: set1){

			boolean matches = false;

			for (IMatchable setItem2: set2){

				matches |= matchStrategy.invoke(setItem1, setItem2);

			}

			if (matches == false){

				return false;

			}

		}

		return result;

	}

	/**

	 * @param value1

	 * @param matchStrategy

	 * @return

	 * @throws MatchException

	 */

	private boolean matchList(Collection value1, Collection value2, IMatchStrategy matchStrategy)

			throws MatchException {

		boolean result;

		List<IMatchable> list1 = (List<IMatchable>)value1;

		List<IMatchable> list2 = (List<IMatchable>)value2;

		if(list1 == null && list2 == null) {

			return true;

		}

		if ((list1 != null && list2 == null) || (list1 == null && list2 != null) || (list1.size()!= list2.size())){

			return false;

		}

		result = true;

		for (int i = 0; i < list1.size(); i++){

			IMatchable listObject1 = list1.get(i);

			IMatchable listObject2 = list2.get(i);

			if (! matchStrategy.invoke(listObject1, listObject2)){

				return false;

			}

		}

		return result;

	}

	private Class<?> getTypeOfSet(Field field) throws MatchException{

		Type genericType = (ParameterizedType)field.getGenericType();

		if (genericType instanceof ParameterizedType/*Impl*/){

			ParameterizedType paraType = (ParameterizedType)genericType;

			paraType.getRawType();

			Type[] arguments = paraType.getActualTypeArguments();

			if (arguments.length == 1){

				Class<?> collectionClass;

				try {

					if (arguments[0] instanceof Class){

						return (Class)arguments[0];

					}else if(arguments[0] instanceof TypeVariable/*Impl*/){

						TypeVariable typeVariable = (TypeVariable)arguments[0];

						GenericDeclaration genericDeclaration = typeVariable.getGenericDeclaration();

						return (Class)genericDeclaration;

					}else{

						logger.warn("Unknown Type");

						throw new MatchException("");

					}

				} catch (Exception e) {

					logger.warn(e.getMessage());

					throw new MatchException("");

				}

			}else{

				logger.warn("Length of arguments <> 1");

				throw new MatchException("");

			}

		}else{

			logger.warn("Not a generic type of type ParameterizedTypeImpl");

			throw new MatchException("Collection type could not be determined. Generic type is not of type ParamterizedTypeImpl");

		}

	}

	/**

	 * 

	 */

	private void initMapping() {

		boolean includeStatic = false;

		boolean includeTransient = false;

		boolean makeAccessible = true;

		matchFields = CdmUtils.getAllFields(matchClass, CdmBase.class, includeStatic, includeTransient, makeAccessible, true);

		for (Field field: matchFields.values()){

			initField(field, false);

		}

	}

	/**

	 * Initializes the matching for a single field

	 * @param field

	 */

	private void initField(Field field, boolean temporary) {

		MatchMode matchMode = null;

		IMatchStrategy matchStrategy = null;

		for (Annotation annotation : field.getAnnotations()){

			if (annotation.annotationType() == Match.class){

				Match match = ((Match)annotation);

				matchMode = match.value();

				if (matchMode == MatchMode.CACHE){

					ReplaceMode replaceMode = match.cacheReplaceMode();

					String[] cachePropertyReplaces = match.cacheReplacedProperties();

					MatchMode replaceMatchMode = match.replaceMatchMode();

					matching.addCacheMatcher(CacheMatcher.NewInstance(field, replaceMode, cachePropertyReplaces, replaceMatchMode));

				}else{

					matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode), temporary);

				}

			}

		}

		Class fieldType = field.getType();

		if (matchMode == null){

			if (isCollection(fieldType)){

				matchMode = defaultCollectionMatchMode;

				matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode), temporary);

			}else if (fieldType.isInterface()){

				//TODO could be handled more sophisticated

				matchMode = defaultMatchMatchMode;

				matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode, matchStrategy), temporary);

			}else if (isSingleCdmBaseObject(fieldType)){

				if (IMatchable.class.isAssignableFrom(fieldType)){

					matchMode = defaultMatchMatchMode;

					if (matchStrategy == null){

						if (fieldType == this.matchClass){

							matchStrategy = this;

						}else{

							matchStrategy = DefaultMatchStrategy.NewInstance(fieldType);

						}

					}

					matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode, matchStrategy), temporary);

				}else{

					matchMode = defaultMatchMode;

					matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode), temporary);

				}

			}else{

				matchMode = defaultMatchMode;

				matching.setFieldMatcher(FieldMatcher.NewInstance(field, matchMode), temporary);

			}	

		}

	}

	@Override

	public Set<String> getMatchFieldPropertyNames() {

		return matchFields.keySet();

	}

}