/// <summary>
/// Performs a lookup for the givern security id if recursiveLookup is true.
/// </summary>
/// <param name="securityIdDetails">The details of the security id for which to perform lookup.</param>
/// <param name="lookupService">The lookup service to use</param>
/// <returns>the security data.</returns>
///
/// <exception cref="UnknownSecurityIdTypeException">
/// if the type of the given security id is unknown.
/// </exception>
/// <exception cref="InvalidSecurityIdFormatException">if the format of security id is invalid.</exception>
/// <exception cref="SecurityIdParsingException">if any other error occurs in parsing the id.</exception>
/// <exception cref="ServiceNotAvailableException">if the lookup service is not available.</exception>
/// <exception cref="SecurityLookupException">if any error occurs when looking up the security data.</exception>
/// <exception cref="SecurityDataCombiningException">if fail to combine the security data.</exception>
private SecurityData PerformRecursiveLookup(SecurityIdDetails securityIdDetails,
ISecurityLookupService lookupService)
{
// check cache to get the securityDataRecord
SecurityDataRecord securityDataRecord = securityDataCache[securityIdDetails.Id] as SecurityDataRecord;
if (securityDataRecord != null)
{
return(securityDataRecord.SecurityData);
}
else
{
//Get the security data for lookupService
SecurityData securityData = lookupService.Lookup(securityIdDetails);
//Add current id to cache. This prevents from infinite recursion due to cyclic references.
securityDataCache[securityIdDetails.Id] = new SecurityDataRecord(securityData, true);
//Create all possible cross-references and store in combinedData
SecurityData combinedData = securityData;
foreach (string refId in securityData.ReferenceIds)
{
//Check the reference id in cache
SecurityDataRecord refRecord = securityDataCache[refId] as SecurityDataRecord;
SecurityData refData;
//if not present in cache, the load from lookup
if (refRecord == null)
{
//Get details of the reference id
SecurityIdDetails refDetails = securityIdParser.Parse(refId);
//get lookup service for the refId
ISecurityLookupService refLookupService = null;
securityLookupServices.TryGetValue(refDetails.Type, out refLookupService);
//No lookup service found for current type.
if (refLookupService == null)
{
throw new NoSuchSecurityLookupServiceException(
"No lookup service exists for the security type: " + refDetails.Type);
}
refData = PerformRecursiveLookup(securityIdParser.Parse(refId), refLookupService);
}
else
{
refData = refRecord.SecurityData;
}
//Combine the current combined data with
combinedData = securityDataCombiner.Combine(combinedData, refData);
}
//All cross-refernced ids must now point to the same combinedData instance
AddUpdateCache(combinedData);
return(combinedData);
}
}
/// <summary>
/// Adds all the reference ids of the combinedSecurityData to the cache.
/// </summary>
/// <param name="combinedSecurityData">The securityData to add to cache</param>
private void AddUpdateCache(SecurityData combinedSecurityData)
{
//Add/update all combined references to cache.
foreach (string refId in combinedSecurityData.ReferenceIds)
{
//Check the reference id in cache
SecurityDataRecord refSecurityData = securityDataCache[refId] as SecurityDataRecord;
//Update the referenceId in combinedSecurityData
SecurityData newSecurityData = new SecurityData(refId, combinedSecurityData.CompanyName,
combinedSecurityData.ReferenceIds);
//update cache for current id. Set looked up to true
if (refId == combinedSecurityData.Id)
{
securityDataCache[refId] = new SecurityDataRecord(newSecurityData, true);
}
//If the reference id is already in cache then update the cache
else if (refSecurityData != null)
{
securityDataCache[refId] = new SecurityDataRecord(newSecurityData, refSecurityData.IsLookedUp);
}
//if not in cache and not looked up yet.
else if (refId != combinedSecurityData.Id)
{
securityDataCache[refId] = new SecurityDataRecord(newSecurityData, false);
}
}
}
/// <summary>
/// Performs a lookup for the givern security id if recursiveLookup is false and referenceLookup is true.
/// </summary>
/// <param name="securityIdDetails">The details of the security id for which to perform lookup.</param>
/// <param name="lookupService">The lookup service to use</param>
/// <returns>the security data.</returns>
///
/// <exception cref="ServiceNotAvailableException">if the lookup service is not available.</exception>
/// <exception cref="SecurityLookupException">if any error occurs when looking up the security data.</exception>
/// <exception cref="SecurityDataCombiningException">if fail to combine the security data.</exception>
private SecurityData PerformReferenceLookup(SecurityIdDetails securityIdDetails,
ISecurityLookupService lookupService)
{
// check cache to get the securityDataRecord
SecurityDataRecord securityDataRecord = securityDataCache[securityIdDetails.Id] as SecurityDataRecord;
if (securityDataRecord != null && securityDataRecord.IsLookedUp)
{
return(securityDataRecord.SecurityData);
}
else if (securityDataRecord == null)
{
return(PerformSimpleLookup(securityIdDetails, lookupService));
}
else
{
//Get the security data for lookupService
SecurityData securityData = lookupService.Lookup(securityIdDetails);
//Combine the record in cache with the one returned.
securityData = securityDataCombiner.Combine(securityData, securityDataRecord.SecurityData);
//Add or update cache with the cross-referenced security data
AddUpdateCache(securityData);
return(securityData);
}
}
/// <summary>
/// Performs a lookup for the givern security id if recursiveLookup and referenceLookup are both false.
/// </summary>
/// <param name="securityIdDetails">The details of the security id for which to perform lookup.</param>
/// <param name="lookupService">The lookup service to use</param>
/// <returns>the security data.</returns>
///
/// <exception cref="ServiceNotAvailableException">if the lookup service is not available.</exception>
/// <exception cref="SecurityLookupException">if any error occurs when looking up the security data.</exception>
/// <exception cref="SecurityDataCombiningException">if fail to combine the security data.</exception>
private SecurityData PerformSimpleLookup(SecurityIdDetails securityIdDetails,
ISecurityLookupService lookupService)
{
// check cache to get the securityDataRecord
SecurityDataRecord securityDataRecord = securityDataCache[securityIdDetails.Id] as SecurityDataRecord;
if (securityDataRecord != null)
{
return(securityDataRecord.SecurityData);
}
else
{
//If not in cache then perform lookup
SecurityData securityData = lookupService.Lookup(securityIdDetails);
//Combine with itself. Combining a securityData instance with itself has the effect of
//adding the securityID to the referenceIds
SecurityData combinedData = securityDataCombiner.Combine(securityData, securityData);
//Create all possible cross references
foreach (string refId in securityData.ReferenceIds)
{
//Check the reference id in cache
SecurityDataRecord refSecurityData = securityDataCache[refId] as SecurityDataRecord;
if (refSecurityData != null)
{
combinedData = securityDataCombiner.Combine(securityData, refSecurityData.SecurityData);
}
}
//Add or update cache with the cross-referenced security data
AddUpdateCache(combinedData);
return(combinedData);
}
}
public void TestConstructorFail11()
{
sdr = new SecurityDataRecord(null, true);
}
public void TearDown()
{
sd = null;
sdr = null;
}
public void SetUp()
{
sd = new SecurityData("A", "B");
sdr = new SecurityDataRecord(sd, true);
}