/**
* Copyright (C) 2009 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.core.position.impl;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import com.opengamma.DataNotFoundException;
import com.opengamma.core.change.ChangeManager;
import com.opengamma.core.change.DummyChangeManager;
import com.opengamma.core.position.Portfolio;
import com.opengamma.core.position.PortfolioNode;
import com.opengamma.core.position.Position;
import com.opengamma.core.position.PositionSource;
import com.opengamma.core.position.Trade;
import com.opengamma.id.IdUtils;
import com.opengamma.id.ObjectId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.UniqueIdSupplier;
import com.opengamma.id.VersionCorrection;
import com.opengamma.util.ArgumentChecker;
/**
* A simple mutable implementation of a source of positions.
* <p>
* This class is intended for testing scenarios.
* It is not thread-safe and must not be used in production.
*/
public class MockPositionSource implements PositionSource {
// this is currently public for indirect use by another project via ViewTestUtils
/**
* The portfolios.
*/
private final Map<ObjectId, Portfolio> _portfolios = new ConcurrentHashMap<ObjectId, Portfolio>();
/**
* A cache of nodes by identifier.
*/
private final Map<ObjectId, PortfolioNode> _nodes = new ConcurrentHashMap<ObjectId, PortfolioNode>();
/**
* A cache of positions by identifier.
*/
private final Map<ObjectId, Position> _positions = new ConcurrentHashMap<ObjectId, Position>();
/**
* A cache of trades by identifier.
*/
private final Map<ObjectId, Trade> _trades = new ConcurrentHashMap<ObjectId, Trade>();
/**
* The suppler of unique identifiers.
*/
private final UniqueIdSupplier _uniqueIdSupplier;
/**
* Creates an instance using the default scheme for each {@link UniqueId} created.
*/
public MockPositionSource() {
_uniqueIdSupplier = new UniqueIdSupplier("Mock");
}
//-------------------------------------------------------------------------
@Override
public Portfolio getPortfolio(final UniqueId uniqueId, final VersionCorrection versionCorrection) {
ArgumentChecker.notNull(uniqueId, "uniqueId");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
Portfolio portfolio = _portfolios.get(uniqueId.getObjectId());
if (portfolio == null) {
throw new DataNotFoundException("Portfolio not found: " + uniqueId);
}
return portfolio;
}
@Override
public Portfolio getPortfolio(ObjectId objectId, VersionCorrection versionCorrection) {
ArgumentChecker.notNull(objectId, "objectId");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
Portfolio portfolio = _portfolios.get(objectId);
if (portfolio == null) {
throw new DataNotFoundException("Portfolio not found: " + objectId);
}
return portfolio;
}
@Override
public PortfolioNode getPortfolioNode(final UniqueId uniqueId, final VersionCorrection versionCorrection) {
ArgumentChecker.notNull(uniqueId, "uniqueId");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
PortfolioNode node = _nodes.get(uniqueId.getObjectId());
if (node == null) {
throw new DataNotFoundException("PortfolioNode not found: " + uniqueId);
}
return node;
}
@Override
public Position getPosition(UniqueId uniqueId) {
ArgumentChecker.notNull(uniqueId, "uniqueId");
Position position = _positions.get(uniqueId.getObjectId());
if (position == null) {
throw new DataNotFoundException("Position not found: " + uniqueId);
}
return position;
}
@Override
public Position getPosition(final ObjectId objectId, final VersionCorrection versionCorrection) {
ArgumentChecker.notNull(objectId, "objectId");
ArgumentChecker.notNull(versionCorrection, "versionCorrection");
Position position = _positions.get(objectId);
if (position == null) {
throw new DataNotFoundException("Position not found: " + objectId);
}
return position;
}
@Override
public Trade getTrade(UniqueId uniqueId) {
ArgumentChecker.notNull(uniqueId, "uniqueId");
Trade trade = _trades.get(uniqueId.getObjectId());
if (trade == null) {
throw new DataNotFoundException("Trade not found: " + uniqueId);
}
return trade;
}
//-------------------------------------------------------------------------
@Override
public ChangeManager changeManager() {
return DummyChangeManager.INSTANCE;
}
//-------------------------------------------------------------------------
/**
* Gets the list of all portfolio identifiers.
*
* @return the portfolio identifiers, unmodifiable, not null
*/
public Set<ObjectId> getPortfolioIds() {
return _portfolios.keySet();
}
/**
* Adds a portfolio to the master.
*
* @param portfolio the portfolio to add, not null
*/
public void addPortfolio(Portfolio portfolio) {
ArgumentChecker.notNull(portfolio, "portfolio");
_portfolios.put(portfolio.getUniqueId().getObjectId(), portfolio);
addToCache(portfolio.getUniqueId().getValue(), null, portfolio.getRootNode());
}
/**
* Adds a node to the cache.
*
* @param portfolioId the id, not null
* @param node the node to add, not null
*/
private void addToCache(String portfolioId, UniqueId parentNode, PortfolioNode node) {
// node
if (node instanceof SimplePortfolioNode) {
SimplePortfolioNode nodeImpl = (SimplePortfolioNode) node;
nodeImpl.setUniqueId(_uniqueIdSupplier.getWithValuePrefix(portfolioId + "-"));
nodeImpl.setParentNodeId(parentNode);
}
_nodes.put(node.getUniqueId().getObjectId(), node);
// position
for (Position position : node.getPositions()) {
if (position instanceof SimplePosition) {
SimplePosition positionImpl = (SimplePosition) position;
positionImpl.setUniqueId(_uniqueIdSupplier.getWithValuePrefix(portfolioId + "-"));
//add trades
for (Trade trade : positionImpl.getTrades()) {
IdUtils.setInto(trade, _uniqueIdSupplier.getWithValuePrefix(portfolioId + "-"));
_trades.put(trade.getUniqueId().getObjectId(), trade);
}
}
_positions.put(position.getUniqueId().getObjectId(), position);
}
// recurse
for (PortfolioNode child : node.getChildNodes()) {
addToCache(portfolioId, node.getUniqueId(), child);
}
}
/**
* Removes a portfolio from the master.
*
* @param portfolio the portfolio to remove, not null
*/
public void removePortfolio(Portfolio portfolio) {
ArgumentChecker.notNull(portfolio, "portfolio");
_portfolios.remove(portfolio.getUniqueId().getObjectId());
removeFromCache(portfolio.getRootNode());
}
/**
* Removes a node from the cache
*
* @param node the node to remove, not null
*/
private void removeFromCache(PortfolioNode node) {
_nodes.remove(node.getUniqueId().getObjectId());
for (Position position : node.getPositions()) {
for (Trade trade : position.getTrades()) {
_trades.remove(trade.getUniqueId().getObjectId());
}
_positions.remove(position.getUniqueId().getObjectId());
}
for (PortfolioNode child : node.getChildNodes()) {
removeFromCache(child);
}
}
}