/// <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); }