001/*
002 * Licensed to the Apache Software Foundation (ASF) under one or more
003 * contributor license agreements. See the NOTICE file distributed with
004 * this work for additional information regarding copyright ownership.
005 * The ASF licenses this file to You under the Apache license, Version 2.0
006 * (the "License"); you may not use this file except in compliance with
007 * the License. You may obtain a copy of the License at
008 *
009 *      http://www.apache.org/licenses/LICENSE-2.0
010 *
011 * Unless required by applicable law or agreed to in writing, software
012 * distributed under the License is distributed on an "AS IS" BASIS,
013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
014 * See the license for the specific language governing permissions and
015 * limitations under the license.
016 */
017package org.apache.logging.log4j.core.config.plugins.convert;
018
019import java.lang.reflect.ParameterizedType;
020import java.lang.reflect.Type;
021import java.util.Collection;
022import java.util.Map;
023import java.util.UnknownFormatConversionException;
024import java.util.concurrent.ConcurrentHashMap;
025import java.util.concurrent.ConcurrentMap;
026
027import org.apache.logging.log4j.Logger;
028import org.apache.logging.log4j.core.config.plugins.util.PluginManager;
029import org.apache.logging.log4j.core.config.plugins.util.PluginType;
030import org.apache.logging.log4j.core.util.Assert;
031import org.apache.logging.log4j.core.util.ReflectionUtil;
032import org.apache.logging.log4j.core.util.TypeUtil;
033import org.apache.logging.log4j.status.StatusLogger;
034
035/**
036 * Registry for {@link TypeConverter} plugins.
037 *
038 * @since 2.1
039 */
040public class TypeConverterRegistry {
041
042    private static final Logger LOGGER = StatusLogger.getLogger();
043    private static volatile TypeConverterRegistry INSTANCE;
044    private static final Object INSTANCE_LOCK = new Object();
045
046    private final ConcurrentMap<Type, TypeConverter<?>> registry = new ConcurrentHashMap<Type, TypeConverter<?>>();
047
048    /**
049     * Gets the singleton instance of the TypeConverterRegistry.
050     *
051     * @return the singleton instance.
052     */
053    public static TypeConverterRegistry getInstance() {
054        TypeConverterRegistry result = INSTANCE;
055        if (result == null) {
056            synchronized (INSTANCE_LOCK) {
057                result = INSTANCE;
058                if (result == null) {
059                    INSTANCE = result = new TypeConverterRegistry();
060                }
061            }
062        }
063        return result;
064    }
065
066    /**
067     * Finds a {@link TypeConverter} for the given {@link Type}, falling back to an assignment-compatible TypeConverter
068     * if none exist for the given type. That is, if the given Type does not have a TypeConverter, but another Type
069     * which can be assigned to the given Type <em>does</em> have a TypeConverter, then that TypeConverter will be
070     * used and registered.
071     *
072     * @param type the Type to find a TypeConverter for (must not be {@code null}).
073     * @return a TypeConverter for the given Type.
074     * @throws UnknownFormatConversionException if no TypeConverter can be found for the given type.
075     */
076    public TypeConverter<?> findCompatibleConverter(final Type type) {
077        Assert.requireNonNull(type, "No type was provided");
078        final TypeConverter<?> primary = registry.get(type);
079        // cached type converters
080        if (primary != null) {
081            return primary;
082        }
083        // dynamic enum support
084        if (type instanceof Class<?>) {
085            final Class<?> clazz = (Class<?>) type;
086            if (clazz.isEnum()) {
087                @SuppressWarnings({"unchecked","rawtypes"})
088                final EnumConverter<? extends Enum> converter = new EnumConverter(clazz.asSubclass(Enum.class));
089                registry.putIfAbsent(type, converter);
090                return converter;
091            }
092        }
093        // look for compatible converters
094        for (final Map.Entry<Type, TypeConverter<?>> entry : registry.entrySet()) {
095            final Type key = entry.getKey();
096            if (TypeUtil.isAssignable(type, key)) {
097                LOGGER.debug("Found compatible TypeConverter<{}> for type [{}].", key, type);
098                final TypeConverter<?> value = entry.getValue();
099                registry.putIfAbsent(type, value);
100                return value;
101            }
102        }
103        throw new UnknownFormatConversionException(type.toString());
104    }
105
106    private TypeConverterRegistry() {
107        LOGGER.debug("TypeConverterRegistry initializing.");
108        final PluginManager manager = new PluginManager(TypeConverters.CATEGORY);
109        manager.collectPlugins();
110        loadKnownTypeConverters(manager.getPlugins().values());
111        registerPrimitiveTypes();
112    }
113
114    private void loadKnownTypeConverters(final Collection<PluginType<?>> knownTypes) {
115        for (final PluginType<?> knownType : knownTypes) {
116            final Class<?> clazz = knownType.getPluginClass();
117            if (TypeConverter.class.isAssignableFrom(clazz)) {
118                @SuppressWarnings("rawtypes")
119                final Class<? extends TypeConverter> pluginClass =  clazz.asSubclass(TypeConverter.class);
120                final Type conversionType = getTypeConverterSupportedType(pluginClass);
121                final TypeConverter<?> converter = ReflectionUtil.instantiate(pluginClass);
122                if (registry.putIfAbsent(conversionType, converter) != null) {
123                    LOGGER.warn("Found a TypeConverter [{}] for type [{}] that already exists.", converter,
124                        conversionType);
125                }
126            }
127        }
128    }
129
130    private static Type getTypeConverterSupportedType(@SuppressWarnings("rawtypes") final Class<? extends TypeConverter> typeConverterClass) {
131        for (final Type type : typeConverterClass.getGenericInterfaces()) {
132            if (type instanceof ParameterizedType) {
133                final ParameterizedType pType = (ParameterizedType) type;
134                if (TypeConverter.class.equals(pType.getRawType())) {
135                    // TypeConverter<T> has only one type argument (T), so return that
136                    return pType.getActualTypeArguments()[0];
137                }
138            }
139        }
140        return Void.TYPE;
141    }
142
143    private void registerPrimitiveTypes() {
144        registerTypeAlias(Boolean.class, Boolean.TYPE);
145        registerTypeAlias(Byte.class, Byte.TYPE);
146        registerTypeAlias(Character.class, Character.TYPE);
147        registerTypeAlias(Double.class, Double.TYPE);
148        registerTypeAlias(Float.class, Float.TYPE);
149        registerTypeAlias(Integer.class, Integer.TYPE);
150        registerTypeAlias(Long.class, Long.TYPE);
151        registerTypeAlias(Short.class, Short.TYPE);
152    }
153
154    private void registerTypeAlias(final Type knownType, final Type aliasType) {
155        registry.putIfAbsent(aliasType, registry.get(knownType));
156    }
157
158}