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

Introduction

Here is the source code for com.opengamma.financial.comparison.PositionSetComparator.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.ArrayList;
import java.util.Collection;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;

import org.fudgemsg.FudgeContext;

import com.google.common.collect.Maps;
import com.opengamma.core.position.Position;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.tuple.Pair;

/**
 * Provides comparison operations between sets of {@link Position} objects.
 */
public class PositionSetComparator extends AbstractComparator {

    public PositionSetComparator(final FudgeContext fudgeContext) {
        super(fudgeContext);
    }

    private static Set<PositionInfo> createPositionInfoSet(final ComparisonContext context,
            final Iterable<Position> positions, final int sizeHint) {
        final Map<PositionInfo, PositionInfo> map = Maps.newHashMapWithExpectedSize(sizeHint);
        for (Position position : positions) {
            final PositionInfo info = new PositionInfo(context, position);
            final PositionInfo previous = map.get(info);
            if (previous != null) {
                previous.associateAdditionalUnderlying(position);
            } else {
                map.put(info, info);
            }
        }
        return new HashSet<PositionInfo>(map.keySet());
    }

    /**
     * Produces a comparison of two sets of positions.
     * 
     * @param first first set of positions, not null
     * @param second second set of positions, not null
     * @return the comparison result
     */
    public PositionSetComparison compare(final Iterable<Position> first, final Iterable<Position> second) {
        ArgumentChecker.notNull(first, "first");
        ArgumentChecker.notNull(second, "second");
        final ComparisonContext context = createContext();
        return compare(createPositionInfoSet(context, first, 32), createPositionInfoSet(context, second, 32));
    }

    /**
     * Produces a comparison of two sets of positions.
     * 
     * @param first first set of positions, not null
     * @param second second set of positions, not null
     * @return the comparison result
     */
    public PositionSetComparison compare(final Collection<Position> first, final Collection<Position> second) {
        ArgumentChecker.notNull(first, "first");
        ArgumentChecker.notNull(second, "second");
        final ComparisonContext context = createContext();
        return compare(createPositionInfoSet(context, first, first.size()),
                createPositionInfoSet(context, second, second.size()));
    }

    private static Collection<Position> getUnderlyingPositions(final Collection<PositionInfo> positions) {
        final Collection<Position> result = new ArrayList<Position>(positions.size());
        for (PositionInfo position : positions) {
            position.addUnderlyingToCollection(result);
        }
        return result;
    }

    private PositionSetComparison compare(final Set<PositionInfo> first, final Set<PositionInfo> second) {
        final Iterator<PositionInfo> itrFirst = first.iterator();
        final Collection<Position> intersection = new ArrayList<Position>();
        // Remove the identical positions first to lower the size of the sets
        while (itrFirst.hasNext()) {
            final PositionInfo position = itrFirst.next();
            if (second.remove(position)) {
                // Second portfolio contained an equivalent position
                position.addUnderlyingToCollection(intersection);
                itrFirst.remove();
            }
        }
        final Collection<Pair<Position, Position>> diff = new ArrayList<Pair<Position, Position>>();
        // TODO: identify changes
        // Anything left in either set is unique to that set
        return new PositionSetComparison(diff, getUnderlyingPositions(first), getUnderlyingPositions(second),
                intersection);
    }

}