com.opengamma.financial.comparison.PositionSetComparison.java Source code

Introduction

Here is the source code for com.opengamma.financial.comparison.PositionSetComparison.java

Source

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

import java.util.Collection;
import java.util.Collections;

import org.apache.commons.lang.builder.ToStringBuilder;

import com.opengamma.core.position.Position;
import com.opengamma.util.tuple.Pair;

/**
 * Represents the result of a position set comparison operation, providing:
 * <ul>
 * <li>The intersection of identical positions</li>
 * <li>The positions only present in the first set</li>
 * <li>The positions only present in the second set</li>
 * <li>The positions that exist in both but have changed from the first to the second</li>
 * </ul>
 */
public class PositionSetComparison {

    /**
     * Positions that exist in both but have been amended. Each element of the collection
     * is a pair of the initial position and the amended position.
     */
    private final Collection<Pair<Position, Position>> _diff;

    /**
     * Positions that existed only in the first set.
     */
    private final Collection<Position> _left;

    /**
     * Positions that existed only in the second set.
     */
    private final Collection<Position> _right;

    /**
     * Positions that were identical in both sets (the intersection).
     */
    private final Collection<Position> _intersection;

    protected PositionSetComparison(final Collection<Pair<Position, Position>> diff,
            final Collection<Position> left, final Collection<Position> right,
            final Collection<Position> intersection) {
        _diff = Collections.unmodifiableCollection(diff);
        _left = Collections.unmodifiableCollection(left);
        _right = Collections.unmodifiableCollection(right);
        _intersection = Collections.unmodifiableCollection(intersection);
    }

    protected PositionSetComparison(final PositionSetComparison copyFrom) {
        _diff = copyFrom.getChanged();
        _left = copyFrom.getOnlyInFirst();
        _right = copyFrom.getOnlyInSecond();
        _intersection = copyFrom.getIdentical();
    }

    public final Collection<Pair<Position, Position>> getChanged() {
        return _diff;
    }

    public final Collection<Position> getOnlyInFirst() {
        return _left;
    }

    public final Collection<Position> getOnlyInSecond() {
        return _right;
    }

    public final Collection<Position> getIdentical() {
        return _intersection;
    }

    /**
     * Returns true if both sets of positions contained identical values.
     * 
     * @return true if the positions were identical
     */
    public boolean isEqual() {
        return getChanged().isEmpty() && getOnlyInFirst().isEmpty() && getOnlyInSecond().isEmpty();
    }

    @Override
    public String toString() {
        return ToStringBuilder.reflectionToString(this);
    }

}