AvailableOutputImpl.java

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

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

import org.apache.commons.lang.ObjectUtils;

import com.opengamma.engine.value.ValueProperties;
import com.opengamma.util.ArgumentChecker;

/**
 * Describes an available output from an input set.
 * <p>
 * The quality of the output - i.e. how likely it is that the value can be generated from the input set, or how accurate/complete
 * the property sets are - depends on the implementation of {@link AvailableOutputs} that produced it. 
 */
public final class AvailableOutputImpl implements AvailableOutput {

  private final String _valueName;
  private final String _anyValue;
  private final Map<String, ValueProperties> _positionProperties = new HashMap<String, ValueProperties>();
  private ValueProperties _portfolioNodeProperties;

  protected AvailableOutputImpl(final String valueName, final String anyValue) {
    ArgumentChecker.notNull(valueName, "valueName");
    _valueName = valueName;
    _anyValue = anyValue;
  }

  protected static AvailableOutputImpl ofPosition(final AvailableOutputImpl copyFrom, final String securityType) {
    final AvailableOutputImpl newInstance = new AvailableOutputImpl(copyFrom.getValueName(), copyFrom.getAnyValue());
    newInstance._positionProperties.put(securityType, copyFrom._positionProperties.get(securityType));
    return newInstance;
  }

  protected static AvailableOutputImpl ofPosition(final AvailableOutputImpl copyFrom) {
    final AvailableOutputImpl newInstance = new AvailableOutputImpl(copyFrom.getValueName(), copyFrom.getAnyValue());
    newInstance._positionProperties.putAll(copyFrom._positionProperties);
    return newInstance;
  }

  protected static AvailableOutputImpl ofPortfolioNode(final AvailableOutputImpl copyFrom) {
    final AvailableOutputImpl newInstance = new AvailableOutputImpl(copyFrom.getValueName(), copyFrom.getAnyValue());
    newInstance._portfolioNodeProperties = copyFrom._portfolioNodeProperties;
    return newInstance;
  }

  public String getValueName() {
    return _valueName;
  }

  /**
   * Returns the indicator used to indicate a property can take any value in addition to the listed ones, null if no
   * explicit indicator has been used. When there is no indicator, the set of property values may be incomplete -
   * wild-card values may be available.
   * 
   * @return the indicator string, or null if none
   */
  public String getAnyValue() {
    return _anyValue;
  }

  @Override
  public boolean isAvailableOnPosition() {
    return !_positionProperties.isEmpty();
  }

  @Override
  public Set<String> getSecurityTypes() {
    return Collections.unmodifiableSet(_positionProperties.keySet());
  }

  @Override
  public boolean isAvailableOn(final String securityType) {
    return _positionProperties.containsKey(securityType);
  }

  @Override
  public boolean isAvailableOnPortfolioNode() {
    return _portfolioNodeProperties != null;
  }

  /**
   * Merges the available properties (left) with an incoming set (right). The result is the possible
   * properties on the output value. If a property is not defined on all merged components it is optional.
   * If a property is defined on multiple components with different values, the union of the values is
   * taken. The result is not guaranteed to be available but is a reasonable indication of what might be
   * available on an output value.
   * <p>
   * This is a commutative operation; i.e. merge(A, B) gives the same result as merge(B, A).
   * 
   * @param left left component of merge, not null
   * @param right right component of merge, not null
   * @return the merged properties
   */
  private ValueProperties merge(final ValueProperties left, final ValueProperties right) {
    if (right.isEmpty() || right.getProperties().isEmpty()) {
      // left composed against EMPTY or INFINITE (or near-infinite) is unchanged
      return left;
    }
    ValueProperties.Builder builder = left.copy();
    for (String property : left.getProperties()) {
      final Set<String> rightValues = right.getValues(property);
      if (rightValues == null) {
        // Right doesn't define, so make optional
        builder.withOptional(property);
      }
    }
    for (String property : right.getProperties()) {
      final Set<String> rightValues = right.getValues(property);
      final Set<String> leftValues = left.getValues(property);
      if (leftValues == null) {
        // Wasn't defined on the left, so the merged output is the optional version of the right
        if (rightValues.isEmpty()) {
          builder.withAny(property);
        } else {
          builder.with(property, rightValues);
        }
        builder.withOptional(property);
      } else {
        if (leftValues.isEmpty()) {
          if (!rightValues.isEmpty()) {
            // Left is "withAny" but right is restricted so use that
            builder.withoutAny(property);
            if (getAnyValue() != null) {
              builder.with(property, getAnyValue());
            }
            builder.with(property, rightValues);
          }
        } else if (rightValues.isEmpty()) {
          if (getAnyValue() != null) {
            // Include "any" indicator
            builder.with(property, getAnyValue());
          }
        } else {
          // Merge known values from the right
          builder.with(property, rightValues);
        }
        // Use greatest optionality
        if (right.isOptional(property)) {
          builder.withOptional(property);
        }
      }
    }
    return builder.get();
  }

  protected void setPortfolioNodeProperties(final ValueProperties properties) {
    if (_portfolioNodeProperties == null) {
      _portfolioNodeProperties = properties;
    } else {
      _portfolioNodeProperties = merge(_portfolioNodeProperties, properties);
    }
  }

  protected void setPositionProperties(final ValueProperties properties, final String securityType) {
    final ValueProperties existing = _positionProperties.get(securityType);
    if (existing == null) {
      _positionProperties.put(securityType, properties);
    } else {
      _positionProperties.put(securityType, merge(existing, properties));
    }
  }

  @Override
  public ValueProperties getProperties() {
    ValueProperties result = _portfolioNodeProperties;
    for (ValueProperties properties : _positionProperties.values()) {
      if (result == null) {
        result = properties;
      } else {
        result = merge(result, properties);
      }
    }
    return result;
  }

  @Override
  public ValueProperties getPositionProperties(final String securityType) {
    return _positionProperties.get(securityType);
  }

  @Override
  public ValueProperties getPortfolioNodeProperties() {
    return _portfolioNodeProperties;
  }

  @Override
  public String toString() {
    return getClass().getSimpleName() + "[" + getValueName() + ", node=" + _portfolioNodeProperties + ", position=" + _positionProperties + "]";
  }

  @Override
  public int hashCode() {
    int hc = 1;
    hc += (hc << 4) + getValueName().hashCode();
    hc += (hc << 4) + _positionProperties.hashCode();
    hc += (hc << 4) + ObjectUtils.hashCode(_portfolioNodeProperties);
    return hc;
  }

  @Override
  public boolean equals(final Object o) {
    if (o == this) {
      return true;
    }
    if (!(o instanceof AvailableOutputImpl)) {
      return false;
    }
    final AvailableOutputImpl other = (AvailableOutputImpl) o;
    if (!getValueName().equals(other.getValueName())) {
      return false;
    }
    if (!_positionProperties.equals(other._positionProperties)) {
      return false;
    }
    return ObjectUtils.equals(_portfolioNodeProperties, other._portfolioNodeProperties);
  }

}