net.projectmonkey.object.mapper.construction.converter.resolver.ConverterStore Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of object-mapper Show documentation

Object mapping implementation written as an alternative to modelmapper which is able to support inheritance, handles flattening / expanding in a precise way, and is extensible / configurable

The newest version!

package net.projectmonkey.object.mapper.construction.converter.resolver;

import net.projectmonkey.object.mapper.analysis.cache.TypePair;
import net.projectmonkey.object.mapper.construction.PopulationContext;
import net.projectmonkey.object.mapper.construction.converter.CacheableConverter;
import net.projectmonkey.object.mapper.construction.converter.Converter;
import net.projectmonkey.object.mapper.util.Assert;

import java.util.*;

/**
 * @author Andy Moody
 */
public class ConverterStore
{

	private Map, Converter> cacheableConverters;
	private List> nonCacheableConverters;

	public ConverterStore()
	{
		cacheableConverters = new HashMap, Converter>();
		nonCacheableConverters = new ArrayList>();
	}

	public ConverterStore(final ConverterStore customConverterStore)
	{
		this.cacheableConverters = new HashMap, Converter>(customConverterStore.cacheableConverters);
		this.nonCacheableConverters = new ArrayList>(customConverterStore.nonCacheableConverters);
	}

	public void add(final Converter converter)
	{
		Assert.notNull(converter, "converter");
		if(converter instanceof CacheableConverter)
		{
			CacheableConverter cacheableConverter = (CacheableConverter) converter;
			Class[] applicableSourceTypes = cacheableConverter.getApplicableSourceTypes();
			Class[] applicableDestinationTypes = cacheableConverter.getApplicableDestinationTypes();
			for (Class sourceType : applicableSourceTypes)
			{
				for (Class destType : applicableDestinationTypes)
				{
					cacheableConverters.put(TypePair.of(sourceType, destType), converter);
				}
			}
		}
		else
		{
			nonCacheableConverters.add(converter);
		}
	}

	public void addAll(final Converter... converters)
	{
		for (Converter converter : converters)
		{
			add(converter);
		}
	}

	public void remove(final Converter converter)
	{
		Assert.notNull(converter, "converter");
		if(converter instanceof CacheableConverter)
		{
			CacheableConverter cacheableConverter = (CacheableConverter) converter;
			Class[] applicableSourceTypes = cacheableConverter.getApplicableSourceTypes();
			Class[] applicableDestinationTypes = cacheableConverter.getApplicableDestinationTypes();
			for (Class sourceType : applicableSourceTypes)
			{
				for (Class destType : applicableDestinationTypes)
				{
					cacheableConverters.remove(TypePair.of(sourceType, destType));
				}
			}
		}
		else
		{
			nonCacheableConverters.remove(converter);
		}
	}

	public Converter getCached(PopulationContext populationContext)
	{
		Object source = populationContext.getSource();
		Class sourceType = source == null ? populationContext.getSourceType(): source.getClass();
		TypePair pair = TypePair.of(sourceType, populationContext.getDestinationType());
		if(cacheableConverters.containsKey(pair))
		{
			return cacheableConverters.get(pair);
		}
		return null;
	}

	public List> getNonCached()
	{
		return nonCacheableConverters;
	}
}