/**
* Copyright (C) 2012 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.engine.target.resolver;
import com.opengamma.core.change.ChangeManager;
import com.opengamma.core.change.PassthroughChangeManager;
import com.opengamma.engine.target.ComputationTargetTypeMap;
import com.opengamma.engine.target.logger.ResolutionLogger;
import com.opengamma.id.UniqueId;
import com.opengamma.id.UniqueIdentifiable;
import com.opengamma.id.VersionCorrection;
import com.opengamma.lambdava.functions.Function2;
/**
* {@link ObjectResolver} implementation that will use a sequence of resolvers in turn if the first fails.
*
* @param <T> the type to be resolved
*/
public class ChainedResolver<T extends UniqueIdentifiable> implements ObjectResolver<T> {
private static final class ChainedDeepResolver implements DeepResolver {
private final DeepResolver _first;
private final DeepResolver _second;
public ChainedDeepResolver(final DeepResolver first, final DeepResolver second) {
_first = first;
_second = second;
}
// DeepResolver
@Override
public UniqueIdentifiable withLogger(final UniqueIdentifiable underlying, final ResolutionLogger logger) {
UniqueIdentifiable result = _first.withLogger(underlying, logger);
if (result == null) {
result = _second.withLogger(underlying, logger);
}
return result;
}
}
private final ObjectResolver<? extends T> _first;
private final ObjectResolver<? extends T> _second;
private final DeepResolver _deep;
public ChainedResolver(final ObjectResolver<? extends T> first, final ObjectResolver<? extends T> second) {
_first = first;
_second = second;
DeepResolver firstDeep = first.deepResolver();
DeepResolver secondDeep = second.deepResolver();
if (firstDeep != null) {
if (secondDeep != null) {
_deep = new ChainedDeepResolver(firstDeep, secondDeep);
} else {
_deep = firstDeep;
}
} else {
_deep = secondDeep;
}
}
protected ObjectResolver<? extends T> getFirst() {
return _first;
}
protected ObjectResolver<? extends T> getSecond() {
return _second;
}
@Override
public T resolveObject(final UniqueId uniqueId, final VersionCorrection versionCorrection) {
T value = getFirst().resolveObject(uniqueId, versionCorrection);
if (value == null) {
value = getSecond().resolveObject(uniqueId, versionCorrection);
}
return value;
}
@Override
public ChangeManager changeManager() {
return new PassthroughChangeManager(getFirst(), getSecond());
}
@Override
public DeepResolver deepResolver() {
return _deep;
}
/**
* Utility function for creating a chain of resolvers, for example when adding them to a {@link ComputationTargetTypeMap}. The first parameter is the second resolver to use (the existing one in the
* map), the second parameter is the first resolver (the new value to the map). The returned value is the resolver chain.
*/
public static final Function2<ObjectResolver<?>, ObjectResolver<?>, ObjectResolver<?>> CREATE = new Function2<ObjectResolver<?>, ObjectResolver<?>, ObjectResolver<?>>() {
@SuppressWarnings({"rawtypes", "unchecked" })
@Override
public ObjectResolver<?> execute(final ObjectResolver<?> second, final ObjectResolver<?> first) {
return new ChainedResolver(first, second);
}
};
}