/**
* Copyright (C) 2011 - present by OpenGamma Inc. and the OpenGamma group of companies
*
* Please see distribution for license.
*/
package com.opengamma.integration.copier.portfolio.writer;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Stack;
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Future;
import org.apache.commons.lang.ArrayUtils;
import org.apache.commons.lang.StringUtils;
import org.joda.beans.JodaBeanUtils;
import org.joda.beans.MetaProperty;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.threeten.bp.Instant;
import com.google.common.collect.ImmutableMap;
import com.opengamma.core.security.SecuritySource;
import com.opengamma.id.ExternalId;
import com.opengamma.id.ExternalIdSearch;
import com.opengamma.id.ObjectId;
import com.opengamma.id.UniqueId;
import com.opengamma.id.VersionCorrection;
import com.opengamma.master.portfolio.ManageablePortfolio;
import com.opengamma.master.portfolio.ManageablePortfolioNode;
import com.opengamma.master.portfolio.PortfolioDocument;
import com.opengamma.master.portfolio.PortfolioMaster;
import com.opengamma.master.portfolio.PortfolioSearchRequest;
import com.opengamma.master.portfolio.PortfolioSearchResult;
import com.opengamma.master.position.ManageablePosition;
import com.opengamma.master.position.ManageableTrade;
import com.opengamma.master.position.PositionDocument;
import com.opengamma.master.position.PositionMaster;
import com.opengamma.master.position.PositionSearchRequest;
import com.opengamma.master.position.PositionSearchResult;
import com.opengamma.master.security.ManageableSecurity;
import com.opengamma.master.security.ManageableSecurityLink;
import com.opengamma.master.security.SecurityDocument;
import com.opengamma.master.security.SecurityMaster;
import com.opengamma.master.security.SecuritySearchRequest;
import com.opengamma.master.security.SecuritySearchResult;
import com.opengamma.master.security.SecuritySearchSortOrder;
import com.opengamma.master.security.impl.MasterSecuritySource;
import com.opengamma.util.ArgumentChecker;
import com.opengamma.util.beancompare.BeanCompare;
import com.opengamma.util.tuple.ObjectsPair;
/**
* A class that writes securities and portfolio positions and trades to the OG masters
*/
public class MasterPortfolioWriter implements PortfolioWriter {
private static final Logger s_logger = LoggerFactory.getLogger(MasterPortfolioWriter.class);
private static final int NUMBER_OF_THREADS = 30;
private final PortfolioMaster _portfolioMaster;
private final PositionMaster _positionMaster;
private final SecurityMaster _securityMaster;
private final SecuritySource _securitySource;
private PortfolioDocument _portfolioDocument;
private ManageablePortfolioNode _currentNode;
private ManageablePortfolioNode _originalNode;
private ManageablePortfolioNode _originalRoot;
private String[] _currentPath;
private BeanCompare _beanCompare;
private boolean _mergePositions;
private Map<ObjectId, ManageablePosition> _securityIdToPosition;
private boolean _keepCurrentPositions;
private boolean _discardIncompleteOptions;
private boolean _multithread;
private ExecutorService _executorService;
/**
* Create a master portfolio writer
* @param portfolioName The name of the portfolio to create/write to
* @param portfolioMaster The portfolio master to which to write the portfolio
* @param positionMaster The position master to which to write positions
* @param securityMaster The security master to which to write securities
* @param mergePositions If true, attempt to roll multiple positions in the same security into one position,
* for all positions in the same portfolio node;
* if false, each position is loaded separately
* @param keepCurrentPositions If true, keep the existing portfolio node tree and add new entries;
* if false, delete the entire existing portfolio node tree before loading the new
* portfolio
* @param discardIncompleteOptions If true, when an underlying cannot be loaded, the position/trade will be discarded;
* if false, the option will be created with a dangling reference to the underlying
*/
public MasterPortfolioWriter(String portfolioName,
PortfolioMaster portfolioMaster,
PositionMaster positionMaster,
SecurityMaster securityMaster,
boolean mergePositions,
boolean keepCurrentPositions,
boolean discardIncompleteOptions) {
this(portfolioName, portfolioMaster, positionMaster, securityMaster, mergePositions,
keepCurrentPositions, discardIncompleteOptions, false);
}
public MasterPortfolioWriter(String portfolioName,
PortfolioMaster portfolioMaster,
PositionMaster positionMaster,
SecurityMaster securityMaster,
boolean mergePositions,
boolean keepCurrentPositions,
boolean discardIncompleteOptions,
boolean multithread) {
ArgumentChecker.notEmpty(portfolioName, "portfolioName");
ArgumentChecker.notNull(portfolioMaster, "portfolioMaster");
ArgumentChecker.notNull(positionMaster, "positionMaster");
ArgumentChecker.notNull(securityMaster, "securityMaster");
_mergePositions = mergePositions;
_keepCurrentPositions = keepCurrentPositions;
_discardIncompleteOptions = discardIncompleteOptions;
_portfolioMaster = portfolioMaster;
_positionMaster = positionMaster;
_securityMaster = securityMaster;
_securitySource = new MasterSecuritySource(_securityMaster);
// unique ID and external ID bundle are ignored when comparing securities
Comparator<Object> alwaysEqualComparator = new Comparator<Object>() {
@Override
public int compare(Object notUsed1, Object notUsed2) {
return 0;
}
};
Map<MetaProperty<?>, Comparator<Object>> comparators = ImmutableMap.<MetaProperty<?>, Comparator<Object>>of(
ManageableSecurity.meta().uniqueId(), alwaysEqualComparator,
ManageableSecurity.meta().externalIdBundle(), alwaysEqualComparator);
_beanCompare = new BeanCompare(comparators, Collections.<Class<?>, Comparator<Object>>emptyMap());
//_currentPath = new String[0];
//_securityIdToPosition = new HashMap<ObjectId, ManageablePosition>();
_multithread = multithread;
if (_multithread) {
_executorService = Executors.newFixedThreadPool(NUMBER_OF_THREADS);
}
createPortfolio(portfolioName);
_securityIdToPosition = new HashMap<>();
setPath(new String[0]);
}
@Override
public void addAttribute(String key, String value) {
_portfolioDocument.getPortfolio().addAttribute(key, value);
}
/**
* Returns the sum of the quantities for the specified positions. This is separated out into a method to allow
* custom behaviour for different clients. For instance, in one case the sums of the quantities of all the trades
* of both positions might be required, whereas in another case the preference might be to sum the quantities of
* the positions themselves without regard to the quantities specified in their trades (this is the default behaviour).
* This is not featured in the PortfolioWriter interface, and as such is a hack.
* @param position1 the first position
* @param position2 the second position
* @return the sum of the positions' quantities
*/
protected BigDecimal sumPositionQuantities(final ManageablePosition position1, final ManageablePosition position2) {
return position1.getQuantity().add(position2.getQuantity());
}
/**
* WritePosition checks if the position exists in the previous version of the portfolio.
* If so, the existing position is reused.
* @param position the position to be written
* @param securities the security(ies) related to the above position, also to be written; index 1 onwards are underlyings
* @return the positions/securities in the masters after writing, null on failure
*/
@Override
public ObjectsPair<ManageablePosition, ManageableSecurity[]> writePosition(final ManageablePosition position, final ManageableSecurity[] securities) {
ArgumentChecker.notNull(position, "position");
ArgumentChecker.notNull(securities, "securities");
// Write securities
final List<ManageableSecurity> writtenSecurities = new ArrayList<>();
for (ManageableSecurity security : securities) {
if (security != null || !_discardIncompleteOptions) { // latter term preserves old behaviour
ManageableSecurity writtenSecurity = writeSecurity(security);
if (writtenSecurity != null) {
writtenSecurities.add(writtenSecurity);
}
}
}
// If no securities were actually written successfully, just skip writing this position entirely
if (writtenSecurities.size() != securities.length && _discardIncompleteOptions) {
// this does persist the securities that it is given so that we don't keep hitting Bloomberg when there are missing underlyings.
return null;
} else if (writtenSecurities.isEmpty()) { // preserve old behaviour if _discardIncompleteOptions is false
return null;
}
// If merging positions, check if any of the positions in the current node reference the same security id
// and if so, just update the existing position and return
if (_mergePositions && _securityIdToPosition.containsKey(writtenSecurities.get(0).getUniqueId().getObjectId())) {
// Add new quantity to existing position's quantity
final ManageablePosition existingPosition = _securityIdToPosition.get(writtenSecurities.get(0).getUniqueId().getObjectId());
existingPosition.setQuantity(sumPositionQuantities(existingPosition, position));
// Add new trades to existing position's trades
for (ManageableTrade trade : position.getTrades()) {
existingPosition.addTrade(trade);
}
if (!_multithread) {
// Save the updated existing position to the position master
PositionDocument addedDoc = _positionMaster.update(new PositionDocument(existingPosition));
s_logger.debug("Updated position {}, delta position {}", addedDoc.getPosition(), position);
// update position map (huh?)
_securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), addedDoc.getPosition());
// Return the updated position
return new ObjectsPair<>(addedDoc.getPosition(),
securities);
} else {
// update position map
_securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), existingPosition);
// Return the updated position
return new ObjectsPair<>(existingPosition, securities);
}
}
// Attempt to reuse an existing position from the previous version of the portfolio, and return if an exact match is found
if (!(_originalNode == null) && !_originalNode.getPositionIds().isEmpty()) {
ManageablePosition existingPosition = matchExistingPosition(position, writtenSecurities);
if (existingPosition != null) {
return new ObjectsPair<>(existingPosition,
writtenSecurities.toArray(new ManageableSecurity[writtenSecurities.size()]));
}
}
// If security has no ExternalId, link position to security ObjectId now
if (position.getSecurityLink().getExternalId().isEmpty() && position.getSecurityLink().getObjectId() == null) {
position.setSecurityLink(ManageableSecurityLink.of(writtenSecurities.get(0)));
}
// also check trades within position for a valid securityLink
for (ManageableTrade trade : position.getTrades()) {
if (trade.getSecurityLink().getExternalId().isEmpty() && trade.getSecurityLink().getObjectId() == null) {
trade.setSecurityLink(ManageableSecurityLink.of(writtenSecurities.get(0))); // or reuse link from position?
}
}
// No existing position could be reused/updated: just Add the new position to the position master as a new document
// (can't launch a thread since we need the position id immediately, to be stored with the pos document in the map)
PositionDocument addedDoc;
try {
addedDoc = _positionMaster.add(new PositionDocument(position));
s_logger.debug("Added position {}", position);
} catch (Exception e) {
s_logger.error("Unable to add position " + position.getUniqueId() + ": " + e.getMessage());
return null;
}
// Add the new position to the portfolio
_currentNode.addPosition(addedDoc.getUniqueId());
// Update position map
_securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), addedDoc.getPosition());
// Return the new position
return new ObjectsPair<>(addedDoc.getPosition(),
writtenSecurities.toArray(new ManageableSecurity[writtenSecurities.size()]));
}
private ManageablePosition matchExistingPosition(final ManageablePosition position, final List<ManageableSecurity> writtenSecurities) {
PositionSearchRequest searchReq = new PositionSearchRequest();
// Filter positions in current node of original portfolio
searchReq.setPositionObjectIds(_originalNode.getPositionIds());
// Filter positions with the same quantity
searchReq.setMinQuantity(position.getQuantity());
searchReq.setMaxQuantity(position.getQuantity());
// TODO Compare position attributes
PositionSearchResult searchResult = _positionMaster.search(searchReq);
for (ManageablePosition existingPosition : searchResult.getPositions()) {
ManageablePosition chosenPosition = null;
if (writtenSecurities.get(0).getUniqueId().getObjectId().equals(existingPosition.getSecurityLink().getObjectId())) {
chosenPosition = existingPosition;
} else {
for (ExternalId id : existingPosition.getSecurityLink().getExternalIds()) {
if (writtenSecurities.get(0).getExternalIdBundle().contains(id) && existingPosition.getQuantity().equals(position.getQuantity())) {
chosenPosition = existingPosition;
break;
}
}
}
// Check for trade equality
if (chosenPosition != null && (chosenPosition.getTrades().size() == position.getTrades().size())) {
for (ManageableTrade trade : chosenPosition.getTrades()) {
ManageableTrade comparableTrade = JodaBeanUtils.clone(trade);
comparableTrade.setUniqueId(null);
if (!(position.getTrades().contains(comparableTrade))) {
chosenPosition = null;
break;
}
}
// If identical, reuse the chosen position
if (chosenPosition != null) {
// Add the existing position to the portfolio
_currentNode.addPosition(chosenPosition.getUniqueId());
// Update position map
_securityIdToPosition.put(writtenSecurities.get(0).getUniqueId().getObjectId(), chosenPosition);
// return existing position
return chosenPosition;
}
}
}
return null;
}
/**
* Searches for an existing security that matches an {@code ExternalId} search, and attempts to
* reuse/update it wherever possible, instead of creating a new one.
* @param security The security to be written to the master.
* @return The new security as added to the master or the existing security found in the master
*/
protected ManageableSecurity writeSecurity(ManageableSecurity security) {
ArgumentChecker.notNull(security, "security");
SecuritySearchResult searchResult = lookupSecurity(security);
ManageableSecurity foundSecurity = updateSecurityVersionIfFound(security, searchResult);
if (foundSecurity != null) {
return foundSecurity;
} else {
return addSecurity(security);
}
}
/**
* Adds a security to master and returns the newly added security. Returns null if
* unable to add security
*/
private ManageableSecurity addSecurity(ManageableSecurity security) {
SecurityDocument addDoc = new SecurityDocument(security);
try {
SecurityDocument result = _securityMaster.add(addDoc);
return result.getSecurity();
} catch (Exception e) {
s_logger.error("Failed to write security " + security + " to the security master", e);
return null;
}
}
/**
* If there is an existing {@code ManageableSecurity} in the searchResult that matches security, for the 1st match:
* <p><ul>
* <li>if the only difference is the {@link UniqueId} do nothing and return the existing
* <li> If there are other differences, update the existing and return the new security
* <li> If there are no matches or any errors are encountered, return null
* @param security new security being searched for
* <ul><p>
* @param searchResult results from search of Master for security
* @return found or updated security, null if no matches
*/
protected ManageableSecurity updateSecurityVersionIfFound(ManageableSecurity security, SecuritySearchResult searchResult) {
for (ManageableSecurity foundSecurity : searchResult.getSecurities()) {
if (foundSecurity.getClass().equals(security.getClass())) {
s_logger.info("Returning existing security " + foundSecurity);
return foundSecurity;
}
}
return null;
// TODO this is too prone to finding trivial differences and creating unnecessary new security versions
/*for (ManageableSecurity foundSecurity : searchResult.getSecurities()) {
List<BeanDifference<?>> differences = null;
if (foundSecurity.getClass().equals(security.getClass())) {
try {
differences = _beanCompare.compare(foundSecurity, security);
} catch (Exception e) {
s_logger.error("Error comparing securities with ID bundle " + security.getExternalIdBundle(), e);
return null;
}
}
if (differences.isEmpty()) {
// It's already there, don't update or add it
return foundSecurity;
} else {
s_logger.debug("Updating security " + foundSecurity + " due to differences: " + differences);
SecurityDocument updateDoc = new SecurityDocument(security);
updateDoc.setVersionFromInstant(Instant.now());
try {
//updateDoc.setUniqueId(foundSecurity.getUniqueId());
//return _securityMaster.update(updateDoc).getSecurity();
UniqueId newId = _securityMaster.addVersion(foundSecurity.getUniqueId().getObjectId(), updateDoc);
security.setUniqueId(newId);
return security;
} catch (Throwable t) {
s_logger.error("Unable to update security " + security.getUniqueId() + ": " + t.getMessage());
return null;
}
}
}
// no matching security in searchResult, return null
return null;*/
}
/**
* Attempts to find a security in the master by {@code ExternalId}. If any of the {@code ExternalId}s on the security
* match any {@code ExternalId} on an existing security, the existing security will be added to the returned
* {@link SecuritySearchResult}. The current version of the existing securities are used.
* @param security new security to search for in Master
* @return search result
*/
protected SecuritySearchResult lookupSecurity(ManageableSecurity security) {
SecuritySearchRequest searchReq = new SecuritySearchRequest();
ExternalIdSearch idSearch = new ExternalIdSearch(security.getExternalIdBundle()); // match any one of the IDs
searchReq.setVersionCorrection(VersionCorrection.ofVersionAsOf(Instant.now())); // valid now
searchReq.setExternalIdSearch(idSearch);
searchReq.setFullDetail(true);
searchReq.setSortOrder(SecuritySearchSortOrder.VERSION_FROM_INSTANT_DESC);
SecuritySearchResult searchResult = _securityMaster.search(searchReq);
return searchResult;
}
private void testQuantities(ManageablePosition position) {
int tradeQty = 0;
for (ManageableTrade trade : position.getTrades()) {
tradeQty += trade.getQuantity().intValue();
}
if (tradeQty != position.getQuantity().intValue()) {
s_logger.warn("Position quantity and total trade quantities do not match for " + position);
}
}
@Override
public String[] getCurrentPath() {
Stack<ManageablePortfolioNode> stack =
_portfolioDocument.getPortfolio().getRootNode().findNodeStackByObjectId(_currentNode.getUniqueId());
String[] result = new String[stack.size()];
int i = stack.size();
while (!stack.isEmpty()) {
result[--i] = stack.pop().getName();
}
return result;
}
@Override
public void setPath(String[] newPath) {
ArgumentChecker.noNulls(newPath, "newPath");
if (!Arrays.equals(newPath, _currentPath)) {
// Update positions in position map, concurrently, and wait for their completion
if (_mergePositions && _multithread) {
List<Callable<Integer>> tasks = new ArrayList<>();
for (final ManageablePosition position : _securityIdToPosition.values()) {
testQuantities(position);
tasks.add(new Callable<Integer>() {
@Override
public Integer call() throws Exception {
try {
// Update the position in the position master
PositionDocument addedDoc = _positionMaster.update(new PositionDocument(position));
s_logger.debug("Updated position {}", position);
// Add the new position to the portfolio node
_currentNode.addPosition(addedDoc.getUniqueId());
} catch (Exception e) {
s_logger.error("Unable to update position " + position.getUniqueId() + ": " + e.getMessage());
}
return 0;
}
});
}
try {
List<Future<Integer>> futures = _executorService.invokeAll(tasks);
} catch (Exception e) {
s_logger.warn("ExecutorService invokeAll failed: " + e.getMessage());
}
}
// Reset position map
_securityIdToPosition = new HashMap<>();
if (_originalRoot != null) {
_originalNode = findNode(newPath, _originalRoot);
_currentNode = getOrCreateNode(newPath, _portfolioDocument.getPortfolio().getRootNode());
} else {
_currentNode = getOrCreateNode(newPath, _portfolioDocument.getPortfolio().getRootNode());
}
// If keeping original portfolio nodes and merging positions, populate position map with existing positions in node
if (_keepCurrentPositions && _mergePositions && _originalNode != null) {
s_logger.debug("Storing security associations for positions " + _originalNode.getPositionIds() + " at path " + StringUtils.join(newPath, '/'));
for (ObjectId positionId : _originalNode.getPositionIds()) {
ManageablePosition position = null;
try {
position = _positionMaster.get(positionId, VersionCorrection.LATEST).getPosition();
} catch (Exception e) {
// no action
s_logger.error("Exception retrieving position " + positionId, e);
}
if (position != null) {
position.getSecurityLink().resolve(_securitySource);
if (position.getSecurity() != null) {
if (_securityIdToPosition.containsKey(position.getSecurity())) {
ManageablePosition existing = _securityIdToPosition.get(position.getSecurity());
s_logger.warn("Merging positions but found existing duplicates under path " + StringUtils.join(newPath, '/') + ": " + position + " and " + existing
+ ". New trades for security " + position.getSecurity().getUniqueId().getObjectId() + " will be added to position " + position.getUniqueId());
} else {
_securityIdToPosition.put(position.getSecurity().getUniqueId().getObjectId(), position);
}
}
}
}
if (s_logger.isDebugEnabled()) {
StringBuilder sb = new StringBuilder("Cached security to position mappings at path ").append(StringUtils.join(newPath, '/')).append(":");
for (Map.Entry<ObjectId, ManageablePosition> entry : _securityIdToPosition.entrySet()) {
sb.append(System.lineSeparator()).append(" ").append(entry.getKey()).append(" = ").append(entry.getValue().getUniqueId());
}
s_logger.debug(sb.toString());
}
}
_currentPath = newPath;
}
}
@Override
public void flush() {
_portfolioDocument = _portfolioMaster.update(_portfolioDocument);
}
@Override
public void close() {
// Execute remaining position writing threads, which will update the portfolio nodes with any written positions'
// object IDs
if (_executorService != null) {
_executorService.shutdown();
}
// Write the portfolio (include the node tree) to the portfolio master
flush();
}
private ManageablePortfolioNode findNode(String[] path, ManageablePortfolioNode startNode) {
// Degenerate case
if (path.length == 0) {
return startNode;
}
for (ManageablePortfolioNode childNode : startNode.getChildNodes()) {
if (path[0].equals(childNode.getName())) {
ManageablePortfolioNode result = findNode((String[]) ArrayUtils.subarray(path, 1, path.length), childNode);
if (result != null) {
return result;
}
}
}
return null;
}
private ManageablePortfolioNode getOrCreateNode(String[] path, ManageablePortfolioNode startNode) {
ManageablePortfolioNode node = startNode;
for (String p : path) {
ManageablePortfolioNode foundNode = null;
for (ManageablePortfolioNode n : node.getChildNodes()) {
if (n.getName().equals(p)) {
foundNode = n;
break;
}
}
if (foundNode == null) {
ManageablePortfolioNode newNode = new ManageablePortfolioNode(p);
node.addChildNode(newNode);
node = newNode;
} else {
node = foundNode;
}
}
return node;
}
protected void createPortfolio(String portfolioName) {
// Check to see whether the portfolio already exists
PortfolioSearchRequest portSearchRequest = new PortfolioSearchRequest();
portSearchRequest.setName(portfolioName);
PortfolioSearchResult portSearchResult = _portfolioMaster.search(portSearchRequest);
_portfolioDocument = portSearchResult.getFirstDocument();
// If it doesn't, create it (add)
if (_portfolioDocument == null) {
// Create a new root node
ManageablePortfolioNode rootNode = new ManageablePortfolioNode(portfolioName);
ManageablePortfolio portfolio = new ManageablePortfolio(portfolioName, rootNode);
_portfolioDocument = new PortfolioDocument();
_portfolioDocument.setPortfolio(portfolio);
_portfolioDocument = _portfolioMaster.add(_portfolioDocument);
_originalRoot = null;
_originalNode = null;
// Set current node to the root node
_currentNode = rootNode;
// If it does, create a new version of the existing portfolio (update)
} else {
ManageablePortfolio portfolio = _portfolioDocument.getPortfolio();
_originalRoot = portfolio.getRootNode();
_originalNode = _originalRoot;
if (_keepCurrentPositions) {
// Use the original root node
portfolio.setRootNode(cloneTree(_originalRoot));
_portfolioDocument.setPortfolio(portfolio);
// Set current node to the root node
_currentNode = portfolio.getRootNode();
} else {
// Create a new root node
ManageablePortfolioNode rootNode;
rootNode = JodaBeanUtils.clone(_originalRoot);
rootNode.setChildNodes(new ArrayList<ManageablePortfolioNode>());
rootNode.setPositionIds(new ArrayList<ObjectId>());
portfolio.setRootNode(rootNode);
_portfolioDocument.setPortfolio(portfolio);
// Set current node to the root node
_currentNode = rootNode;
}
}
}
private static ManageablePortfolioNode cloneTree(final ManageablePortfolioNode originalRoot) {
ManageablePortfolioNode newRoot = JodaBeanUtils.clone(originalRoot);
newRoot.setChildNodes(new ArrayList<ManageablePortfolioNode>());
for (ManageablePortfolioNode child : originalRoot.getChildNodes()) {
newRoot.addChildNode(cloneTree(child));
}
return newRoot;
}
// TODO are these methods necessary? they're not used
public PortfolioMaster getPortfolioMaster() {
return _portfolioMaster;
}
public PositionMaster getPositionMaster() {
return _positionMaster;
}
public SecurityMaster getSecurityMaster() {
return _securityMaster;
}
}