org.sfm.reflect.meta.MapClassMeta Maven / Gradle / Ivy

Go to download
package org.sfm.reflect.meta;

import org.sfm.reflect.InstantiatorDefinition;
import org.sfm.reflect.ReflectionService;
import org.sfm.reflect.TypeHelper;
import org.sfm.utils.conv.Converter;
import org.sfm.utils.conv.ConverterFactory;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

public class MapClassMeta, K, V> implements ClassMeta {

	private final ReflectionService reflectionService;
	private final Converter keyConverter;
	private final ClassMeta valueClassMeta;
	private final Type type;

	private final Constructor constructor;

	public MapClassMeta(Type type, Type keyType, Type valueType, ReflectionService reflectionService) {
		this.type = type;
		this.keyConverter = ConverterFactory.getConverter(CharSequence.class, keyType);
		if (keyConverter == null) {
			throw new IllegalArgumentException("Unsupported key type " + keyType);
		}
		this.reflectionService = reflectionService;
		this.valueClassMeta = reflectionService.getClassMeta(valueType);
		this.constructor = getConstructor(type);
	}

	private Constructor getConstructor(Type type) {

		Class implClass = findMapImpl(type);
		try {
			return implClass.getDeclaredConstructor();
		} catch (NoSuchMethodException e) {
			throw new IllegalArgumentException("No empty constructor for " + implClass);
		}
	}

	private Class findMapImpl(Type type) {
		Class clazz = TypeHelper.toClass(type);

		if (clazz.isInterface()) {
			if (Map.class.equals(clazz)) {
				return HashMap.class;
			} else if(ConcurrentMap.class.equals(clazz)) {
				return ConcurrentHashMap.class;
			}
		} else if (!Modifier.isAbstract(clazz.getModifiers())) {
			return clazz;
		}

		throw new IllegalArgumentException("No known Map impl for " + type);
	}

	@Override
	public ReflectionService getReflectionService() {
		return reflectionService;
	}

	@Override
	public PropertyFinder newPropertyFinder() {
		return new MapPropertyFinder(this, valueClassMeta, keyConverter);
	}

	@Override
	public Type getType() {
		return type;
	}

	@Override
	public String[] generateHeaders() {
		throw new UnsupportedOperationException("Cannot generate headers for map");
	}

	@Override
	public boolean isLeaf() {
		return false;
	}

	@Override
	public List getInstantiatorDefinitions() {
		return Arrays.asList(new InstantiatorDefinition(constructor));
	}
}