MarketDataInjectorImpl.java

/**
 * Copyright (C) 2013 - present by OpenGamma Inc. and the OpenGamma group of companies
 *
 * Please see distribution for license.
 */
package com.opengamma.engine.marketdata;

import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import com.opengamma.engine.ComputationTarget;
import com.opengamma.engine.ComputationTargetResolver;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.marketdata.availability.MarketDataAvailabilityProvider;
import com.opengamma.engine.target.ComputationTargetSpecificationResolver;
import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.engine.value.ValueSpecification;

/**
 * In-memory implementation of a {@link MarketDataInjector}.
 */
public class MarketDataInjectorImpl implements MarketDataInjector {

  private static final Logger s_logger = LoggerFactory.getLogger(MarketDataInjectorImpl.class);

  /**
   * A snapshot of the state of the injection.
   */
  public final class Snapshot {

    private final MarketDataAvailabilityProvider _availability;
    private final Map<ValueRequirement, Object> _valuesByRequirement;
    private final Map<ValueSpecification, Object> _valuesBySpecification;

    private Snapshot(final MarketDataAvailabilityProvider availability, final Map<ValueRequirement, Object> valuesByRequirement, final Map<ValueSpecification, Object> valuesBySpecification) {
      _availability = availability;
      _valuesByRequirement = valuesByRequirement;
      _valuesBySpecification = valuesBySpecification;
    }

    public void init() {
      if (!_valuesByRequirement.isEmpty()) {
        ComputationTargetResolver.AtVersionCorrection targetResolver = getComputationTargetResolver();
        if (targetResolver != null) {
          final ComputationTargetSpecificationResolver.AtVersionCorrection specificationResolver = targetResolver.getSpecificationResolver();
          for (Map.Entry<ValueRequirement, Object> valueByRequirement : _valuesByRequirement.entrySet()) {
            final ComputationTargetSpecification targetSpec = specificationResolver.getTargetSpecification(valueByRequirement.getKey().getTargetReference());
            if (targetSpec != null) {
              final ComputationTarget target = targetResolver.resolve(targetSpec);
              final Object targetValue = (target != null) ? target.getValue() : null;
              final ValueSpecification resolved = _availability.getAvailability(targetSpec, targetValue, valueByRequirement.getKey());
              if (resolved != null) {
                s_logger.info("Injecting {} as {}", valueByRequirement, resolved);
                _valuesBySpecification.put(resolved, valueByRequirement.getValue());
              } else {
                s_logger.debug("Not injecting {} - no availability from {}", valueByRequirement, _availability);
              }
            } else {
              s_logger.warn("Couldn't resolve {} for injected value requirement", valueByRequirement.getKey());
            }
          }
        } else {
          s_logger.warn("Values injected by requirement, but no target resolver");
        }
      }
    }

    public Object query(final ValueSpecification value) {
      return _valuesBySpecification.get(value);
    }

  }

  private final ConcurrentMap<ValueRequirement, Object> _valuesByRequirement = new ConcurrentHashMap<ValueRequirement, Object>();
  private final ConcurrentMap<ValueSpecification, Object> _valuesBySpecification = new ConcurrentHashMap<ValueSpecification, Object>();
  private ComputationTargetResolver.AtVersionCorrection _targetResolver;

  public Snapshot snapshot(final MarketDataAvailabilityProvider availability) {
    if (_valuesByRequirement.isEmpty() && _valuesBySpecification.isEmpty()) {
      return null;
    }
    final Map<ValueRequirement, Object> valuesByRequirement = new HashMap<ValueRequirement, Object>(_valuesByRequirement);
    final Map<ValueSpecification, Object> valuesBySpecification = new HashMap<ValueSpecification, Object>(_valuesBySpecification);
    if (valuesByRequirement.isEmpty() && valuesBySpecification.isEmpty()) {
      return null;
    }
    return new Snapshot(availability, valuesByRequirement, valuesBySpecification);
  }

  public void setComputationTargetResolver(final ComputationTargetResolver.AtVersionCorrection targetResolver) {
    _targetResolver = targetResolver;
  }

  public ComputationTargetResolver.AtVersionCorrection getComputationTargetResolver() {
    return _targetResolver;
  }

  // MarketDataInjector

  @Override
  public void addValue(ValueRequirement valueRequirement, Object value) {
    _valuesByRequirement.put(valueRequirement, value);
  }

  @Override
  public void addValue(ValueSpecification valueSpecification, Object value) {
    _valuesBySpecification.put(valueSpecification, value);
  }

  @Override
  public void removeValue(ValueRequirement valueRequirement) {
    _valuesByRequirement.remove(valueRequirement);
  }

  @Override
  public void removeValue(ValueSpecification valueSpecification) {
    _valuesBySpecification.remove(valueSpecification);
  }

}