CompiledViewDefinitionImpl.java

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

import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

import org.threeten.bp.Instant;

import com.opengamma.core.position.Portfolio;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.value.ValueRequirement;
import com.opengamma.engine.value.ValueSpecification;
import com.opengamma.engine.view.ViewDefinition;
import com.opengamma.id.VersionCorrection;
import com.opengamma.util.ArgumentChecker;

/**
 * Default implementation of {@link CompiledViewDefinition}.
 */
public class CompiledViewDefinitionImpl implements CompiledViewDefinition {

  private final VersionCorrection _versionCorrection;
  private final String _identifier;
  private final ViewDefinition _viewDefinition;
  private final Portfolio _portfolio;
  private final Map<String, CompiledViewCalculationConfiguration> _compiledCalculationConfigurations;
  private final Instant _earliestValidity;
  private final Instant _latestValidity;
  private volatile Set<ValueSpecification> _marketDataRequirements;

  public CompiledViewDefinitionImpl(final VersionCorrection versionCorrection, final String identifier, final ViewDefinition viewDefinition, final Portfolio portfolio,
      final Collection<CompiledViewCalculationConfiguration> compiledCalculationConfigurations, final Instant earliestValidity, final Instant latestValidity) {
    ArgumentChecker.notNull(versionCorrection, "versionCorrection");
    assert !versionCorrection.containsLatest();
    ArgumentChecker.notNull(identifier, "identifier");
    ArgumentChecker.notNull(viewDefinition, "viewDefinition");
    ArgumentChecker.notNull(compiledCalculationConfigurations, "compiledCalculationConfigurations");
    _versionCorrection = versionCorrection;
    _identifier = identifier;
    _viewDefinition = viewDefinition;
    _portfolio = portfolio;
    _compiledCalculationConfigurations = new HashMap<>();
    for (final CompiledViewCalculationConfiguration compiledCalculationConfiguration : compiledCalculationConfigurations) {
      ArgumentChecker.notNull(compiledCalculationConfiguration, "compiledCalculationConfiguration");
      _compiledCalculationConfigurations.put(compiledCalculationConfiguration.getName(), compiledCalculationConfiguration);
    }
    _earliestValidity = earliestValidity;
    _latestValidity = latestValidity;
  }

  protected CompiledViewDefinitionImpl(final CompiledViewDefinitionImpl copyFrom, final VersionCorrection versionCorrection) {
    _versionCorrection = versionCorrection;
    _identifier = copyFrom.getCompilationIdentifier();
    _viewDefinition = copyFrom.getViewDefinition();
    _portfolio = copyFrom.getPortfolio();
    _compiledCalculationConfigurations = copyFrom._compiledCalculationConfigurations;
    _earliestValidity = copyFrom.getValidFrom();
    _latestValidity = copyFrom.getValidTo();
  }

  @Override
  public VersionCorrection getResolverVersionCorrection() {
    return _versionCorrection;
  }

  @Override
  public String getCompilationIdentifier() {
    return _identifier;
  }

  @Override
  public CompiledViewDefinition withResolverVersionCorrection(final VersionCorrection versionCorrection) {
    return new CompiledViewDefinitionImpl(this, versionCorrection);
  }

  @Override
  public ViewDefinition getViewDefinition() {
    return _viewDefinition;
  }

  @Override
  public Portfolio getPortfolio() {
    return _portfolio;
  }

  @Override
  public CompiledViewCalculationConfiguration getCompiledCalculationConfiguration(final String viewCalculationConfiguration) {
    ArgumentChecker.notNull(viewCalculationConfiguration, "viewCalculationConfiguration");
    return _compiledCalculationConfigurations.get(viewCalculationConfiguration);
  }

  @Override
  public Collection<CompiledViewCalculationConfiguration> getCompiledCalculationConfigurations() {
    return Collections.unmodifiableCollection(_compiledCalculationConfigurations.values());
  }

  @Override
  public Map<String, CompiledViewCalculationConfiguration> getCompiledCalculationConfigurationsMap() {
    return Collections.unmodifiableMap(_compiledCalculationConfigurations);
  }

  @Override
  public Set<ValueSpecification> getMarketDataRequirements() {
    if (_marketDataRequirements == null) {
      final Set<ValueSpecification> allRequirements = new HashSet<>();
      for (final CompiledViewCalculationConfiguration compiledCalcConfig : getCompiledCalculationConfigurations()) {
        allRequirements.addAll(compiledCalcConfig.getMarketDataRequirements());
      }
      _marketDataRequirements = Collections.unmodifiableSet(allRequirements);
    }
    return _marketDataRequirements;
  }

  @Override
  public Map<ValueSpecification, Set<ValueRequirement>> getTerminalValuesRequirements() {
    final Map<ValueSpecification, Set<ValueRequirement>> allRequirements = new HashMap<>();
    for (final CompiledViewCalculationConfiguration compiledCalcConfig : getCompiledCalculationConfigurations()) {
      allRequirements.putAll(compiledCalcConfig.getTerminalOutputSpecifications());
    }
    return Collections.unmodifiableMap(allRequirements);
  }

  @Override
  public Set<ComputationTargetSpecification> getComputationTargets() {
    final Set<ComputationTargetSpecification> allTargets = new HashSet<>();
    for (final CompiledViewCalculationConfiguration compiledCalcConfig : getCompiledCalculationConfigurations()) {
      allTargets.addAll(compiledCalcConfig.getComputationTargets());
    }
    return Collections.unmodifiableSet(allTargets);
  }

  @Override
  public Instant getValidFrom() {
    return _earliestValidity;
  }

  @Override
  public Instant getValidTo() {
    return _latestValidity;
  }

  /**
   * Checks whether the compilation results encapsulated in an instance are valid for a specific cycle. Note that this does not ensure that the view definition used for compilation is still
   * up-to-date.
   * 
   * @param viewDefinition the compiled view definition instance, not null
   * @param valuationTime the valuation time, not null
   * @return true if the compilation results are valid for the valuation time
   */
  public static boolean isValidFor(final CompiledViewDefinition viewDefinition, final Instant valuationTime) {
    final Instant validFrom = viewDefinition.getValidFrom();
    if ((validFrom != null) && valuationTime.isBefore(validFrom)) {
      return false;
    }
    final Instant validTo = viewDefinition.getValidTo();
    return (validTo == null) || !valuationTime.isAfter(validTo);
  }

  //-------------------------------------------------------------------------
  @Override
  public String toString() {
    return "CompiledViewDefinition[" + getViewDefinition().getName() + ", " + getValidityString() + "]";
  }

  protected String getValidityString() {
    if (_earliestValidity == null && _latestValidity == null) {
      return "unrestricted validity";
    } else if (_earliestValidity == null) {
      return "valid until " + _latestValidity.toString();
    } else if (_latestValidity == null) {
      return "valid from " + _earliestValidity.toString();
    } else {
      return "valid from " + _earliestValidity.toString() + " to " + _latestValidity.toString();
    }
  }
}