// Copyright 2006, 2007, 2008, 2011, 2012 The Apache Software Foundation
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package org.apache.tapestry5.ioc.util;
import org.apache.tapestry5.ioc.internal.util.CollectionFactory;
import org.apache.tapestry5.ioc.internal.util.InheritanceSearch;
import java.util.Collection;
import java.util.List;
import java.util.Map;
/**
* A key component in implementing the "Gang of Four" Strategy pattern. A StrategyRegistry will match up a given input
* type with a registered strategy for that type.
*
* @param <A> the type of the strategy adapter
*/
public final class StrategyRegistry<A>
{
private final Class<A> adapterType;
private final boolean allowNonMatch;
private final Map<Class, A> registrations = CollectionFactory.newMap();
private final Map<Class, A> cache = CollectionFactory.newConcurrentMap();
/**
* Used to identify types for which there is no matching adapter; we're using it as if it were a ConcurrentSet.
*/
private final Map<Class, Boolean> unmatched = CollectionFactory.newConcurrentMap();
private StrategyRegistry(Class<A> adapterType, Map<Class, A> registrations, boolean allowNonMatch)
{
this.adapterType = adapterType;
this.allowNonMatch = allowNonMatch;
this.registrations.putAll(registrations);
}
/**
* Creates a strategy registry for the given adapter type. The registry will be configured to require matches.
*
* @param adapterType the type of adapter retrieved from the registry
* @param registrations map of registrations (the contents of the map are copied)
*/
public static <A> StrategyRegistry<A> newInstance(Class<A> adapterType,
Map<Class, A> registrations)
{
return newInstance(adapterType, registrations, false);
}
/**
* Creates a strategy registry for the given adapter type.
*
* @param adapterType the type of adapter retrieved from the registry
* @param registrations map of registrations (the contents of the map are copied)
* @param allowNonMatch if true, then the registry supports non-matches when retrieving an adapter
*/
public static <A> StrategyRegistry<A> newInstance(
Class<A> adapterType,
Map<Class, A> registrations, boolean allowNonMatch)
{
return new StrategyRegistry<A>(adapterType, registrations, allowNonMatch);
}
public void clearCache()
{
cache.clear();
unmatched.clear();
}
public Class<A> getAdapterType()
{
return adapterType;
}
/**
* Gets an adapter for an object. Searches based on the value's class, unless the value is null, in which case, a
* search on class void is used.
*
* @param value for which an adapter is needed
* @return the adapter for the value or null if not found (and allowNonMatch is true)
* @throws IllegalArgumentException if no matching adapter may be found and allowNonMatch is false
*/
public A getByInstance(Object value)
{
return get(value == null ? void.class : value.getClass());
}
/**
* Searches for an adapter corresponding to the given input type.
*
* @param type the type to search
* @return the adapter for the type or null if not found (and allowNonMatch is true)
* @throws IllegalArgumentException if no matching adapter may be found and allowNonMatch is false
*/
public A get(Class type)
{
A result = cache.get(type);
if (result != null) return result;
if (unmatched.containsKey(type)) return null;
result = findMatch(type);
// This may be null in the case that there is no match and we're allowing that to not
// be an error. That's why we check via containsKey.
if (result != null)
{
cache.put(type, result);
} else
{
unmatched.put(type, true);
}
return result;
}
private A findMatch(Class type)
{
for (Class t : new InheritanceSearch(type))
{
A result = registrations.get(t);
if (result != null) return result;
}
if (allowNonMatch) return null;
// Report the error. These things really confused the hell out of people in Tap4, so we're
// going the extra mile on the exception message.
List<String> names = CollectionFactory.newList();
for (Class t : registrations.keySet())
names.add(t.getName());
throw new UnknownValueException(String.format("No adapter from type %s to type %s is available.", type.getName(), adapterType.getName()), null, null,
new AvailableValues("registered types", registrations));
}
/**
* Returns the registered types for which adapters are available.
*/
public Collection<Class> getTypes()
{
return CollectionFactory.newList(registrations.keySet());
}
@Override
public String toString()
{
return String.format("StrategyRegistry[%s]", adapterType.getName());
}
}