/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.engine.view.impl;
import java.io.Serializable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.threeten.bp.Duration;
import org.threeten.bp.Instant;
import com.opengamma.engine.ComputationTargetSpecification;
import com.opengamma.engine.value.ComputedValueResult;
import com.opengamma.engine.view.ViewCalculationResultModel;
import com.opengamma.engine.view.ViewResultEntry;
import com.opengamma.engine.view.ViewResultModel;
import com.opengamma.engine.view.ViewTargetResultModel;
import com.opengamma.engine.view.execution.ViewCycleExecutionOptions;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
/**
* A simple in-memory implementation of {@link ViewResultModel}.
*/
public abstract class InMemoryViewResultModel implements ViewResultModel, Serializable {
private static final long serialVersionUID = 1L;
private UniqueId _viewProcessId;
private UniqueId _viewCycleId;
private ViewCycleExecutionOptions _viewCycleExecutionOptions;
private Instant _calculationTime;
private Duration _calculationDuration;
private VersionCorrection _versionCorrection;
private final Map<String, ViewCalculationResultModelImpl> _resultsByConfiguration = new HashMap<String, ViewCalculationResultModelImpl>();
private final Map<ComputationTargetSpecification, ViewTargetResultModelImpl> _resultsByTarget = new HashMap<ComputationTargetSpecification, ViewTargetResultModelImpl>();
public InMemoryViewResultModel() {
}
public InMemoryViewResultModel(final ViewResultModel copyFrom) {
update(copyFrom);
}
/**
* Updates the data held in this model with data from (and about) a delta cycle.
*
* @param delta the delta results, not null
*/
public void update(final ViewResultModel delta) {
setViewProcessId(delta.getViewProcessId());
setViewCycleId(delta.getViewCycleId());
setViewCycleExecutionOptions(delta.getViewCycleExecutionOptions());
setCalculationTime(delta.getCalculationTime());
setCalculationDuration(delta.getCalculationDuration());
setVersionCorrection(delta.getVersionCorrection());
for (String calculationConfiguration : delta.getCalculationConfigurationNames()) {
final ViewCalculationResultModel deltaConfigResults = delta.getCalculationResult(calculationConfiguration);
ViewCalculationResultModelImpl calcConfigResults = _resultsByConfiguration.get(calculationConfiguration);
if (calcConfigResults == null) {
calcConfigResults = new ViewCalculationResultModelImpl();
_resultsByConfiguration.put(calculationConfiguration, calcConfigResults);
}
for (ComputationTargetSpecification target : deltaConfigResults.getAllTargets()) {
for (ComputedValueResult value : deltaConfigResults.getAllValues(target)) {
calcConfigResults.addValue(target, value);
ViewTargetResultModelImpl targetResults = _resultsByTarget.get(target);
if (targetResults == null) {
targetResults = new ViewTargetResultModelImpl();
_resultsByTarget.put(target, targetResults);
}
targetResults.addValue(calculationConfiguration, value);
}
}
}
}
public boolean isEmpty() {
// Adding any results makes the maps non-empty
return _resultsByTarget.isEmpty();
}
@Override
public UniqueId getViewProcessId() {
return _viewProcessId;
}
public void setViewProcessId(UniqueId viewProcessId) {
_viewProcessId = viewProcessId;
}
@Override
public UniqueId getViewCycleId() {
return _viewCycleId;
}
public void setViewCycleId(UniqueId viewCycleId) {
_viewCycleId = viewCycleId;
}
@Override
public ViewCycleExecutionOptions getViewCycleExecutionOptions() {
return _viewCycleExecutionOptions;
}
public void setViewCycleExecutionOptions(ViewCycleExecutionOptions viewCycleExecutionOptions) {
_viewCycleExecutionOptions = viewCycleExecutionOptions;
}
@Override
public Instant getCalculationTime() {
return _calculationTime;
}
public void setCalculationTime(Instant calculationTime) {
_calculationTime = calculationTime;
}
@Override
public Duration getCalculationDuration() {
return _calculationDuration;
}
public void setCalculationDuration(Duration calculationDuration) {
_calculationDuration = calculationDuration;
}
@Override
public VersionCorrection getVersionCorrection() {
return _versionCorrection;
}
public void setVersionCorrection(VersionCorrection versionCorrection) {
_versionCorrection = versionCorrection;
}
@Override
public Set<ComputationTargetSpecification> getAllTargets() {
return Collections.unmodifiableSet(_resultsByTarget.keySet());
}
/**
* For testing.
*/
/* package */ViewCalculationResultModelImpl getCalculationResultModelImpl(final String calcConfigurationName) {
return _resultsByConfiguration.get(calcConfigurationName);
}
public void addValue(final String calcConfigurationName, final ComputedValueResult value) {
final ComputationTargetSpecification target = value.getSpecification().getTargetSpecification();
ViewCalculationResultModelImpl result = _resultsByConfiguration.get(calcConfigurationName);
if (result == null) {
result = new ViewCalculationResultModelImpl();
_resultsByConfiguration.put(calcConfigurationName, result);
}
result.addValue(target, value);
ViewTargetResultModelImpl targetResult = _resultsByTarget.get(target);
if (targetResult == null) {
targetResult = new ViewTargetResultModelImpl();
_resultsByTarget.put(target, targetResult);
}
targetResult.addValue(calcConfigurationName, value);
}
@Override
public Collection<String> getCalculationConfigurationNames() {
return Collections.unmodifiableSet(_resultsByConfiguration.keySet());
}
@Override
public ViewCalculationResultModel getCalculationResult(String calcConfigurationName) {
return _resultsByConfiguration.get(calcConfigurationName);
}
@Override
public ViewTargetResultModel getTargetResult(ComputationTargetSpecification targetSpecification) {
return _resultsByTarget.get(targetSpecification);
}
@Override
public List<ViewResultEntry> getAllResults() {
final ArrayList<ViewResultEntry> results = new ArrayList<ViewResultEntry>();
for (Map.Entry<String, ViewCalculationResultModelImpl> config : _resultsByConfiguration.entrySet()) {
final Collection<ComputationTargetSpecification> targets = config.getValue().getAllTargets();
int numTargets = targets.size();
int totalComputedValues = 0;
int targetsSeen = 0;
for (ComputationTargetSpecification target : targets) {
final Collection<ComputedValueResult> computedValues = config.getValue().getAllValues(target);
totalComputedValues += computedValues.size();
targetsSeen++;
results.ensureCapacity(numTargets * (totalComputedValues / targetsSeen));
for (ComputedValueResult computedValue : computedValues) {
results.add(new ViewResultEntry(config.getKey(), computedValue));
}
}
}
return results;
}
@Override
public Set<String> getAllOutputValueNames() {
Set<String> outputValueNames = new HashSet<String>();
for (ViewResultEntry result : getAllResults()) {
outputValueNames.add(result.getComputedValue().getSpecification().getValueName());
}
return outputValueNames;
}
}