public RelativeDates(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList periodSkipNodeList = xmlNode.SelectNodes("periodSkip");
     if (periodSkipNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in periodSkipNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 periodSkipIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(periodSkipIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 periodSkipIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 periodSkip = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList scheduleBoundsNodeList = xmlNode.SelectNodes("scheduleBounds");
     if (scheduleBoundsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in scheduleBoundsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 scheduleBoundsIDRef = item.Attributes["id"].Name;
                 DateRange ob = DateRange();
                 IDManager.SetID(scheduleBoundsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 scheduleBoundsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 scheduleBounds = new DateRange(item);
             }
         }
     }
     
 
 }
 public ReportIdentification(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList numberOfSectionsNodeList = xmlNode.SelectNodes("numberOfSections");
     if (numberOfSectionsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfSectionsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfSectionsIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(numberOfSectionsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfSectionsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfSections = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");
     if (submissionsCompleteNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in submissionsCompleteNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(submissionsCompleteIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 submissionsCompleteIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 submissionsComplete = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public FutureValueAmount(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");
     if (calculationPeriodNumberOfDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodNumberOfDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodNumberOfDays = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");
     if (valueDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valueDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valueDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(valueDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valueDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valueDate = new XsdTypeDate(item);
             }
         }
     }
     
 
 }
 public ValuationPostponement(XmlNode xmlNode)
 {
     XmlNodeList maximumDaysOfPostponementNodeList = xmlNode.SelectNodes("maximumDaysOfPostponement");
     if (maximumDaysOfPostponementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumDaysOfPostponementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumDaysOfPostponementIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(maximumDaysOfPostponementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumDaysOfPostponementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumDaysOfPostponement = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public MultipleValuationDates(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList businessDaysThereafterNodeList = xmlNode.SelectNodes("businessDaysThereafter");
     if (businessDaysThereafterNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessDaysThereafterNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessDaysThereafterIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(businessDaysThereafterIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessDaysThereafterIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessDaysThereafter = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList numberValuationDatesNodeList = xmlNode.SelectNodes("numberValuationDates");
     if (numberValuationDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberValuationDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberValuationDatesIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(numberValuationDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberValuationDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberValuationDates = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public PortfolioReference(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");
     if (submissionsCompleteNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in submissionsCompleteNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(submissionsCompleteIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 submissionsCompleteIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 submissionsComplete = new XsdTypeBoolean(item);
             }
         }
     }
     
 
 }
 public DenominatorTerm(XmlNode xmlNode)
 {
     XmlNodeList weightedPartialNodeList = xmlNode.SelectNodes("weightedPartial");
     if (weightedPartialNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in weightedPartialNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 weightedPartialIDRef = item.Attributes["id"].Name;
                 WeightedPartialDerivative ob = WeightedPartialDerivative();
                 IDManager.SetID(weightedPartialIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 weightedPartialIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 weightedPartial = new WeightedPartialDerivative(item);
             }
         }
     }
     
 
     XmlNodeList powerNodeList = xmlNode.SelectNodes("power");
     if (powerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in powerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 powerIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(powerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 powerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 power = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public Frequency(XmlNode xmlNode)
 {
     XmlNodeList periodMultiplierNodeList = xmlNode.SelectNodes("periodMultiplier");
     if (periodMultiplierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in periodMultiplierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 periodMultiplierIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(periodMultiplierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 periodMultiplierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 periodMultiplier = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList periodNodeList = xmlNode.SelectNodes("period");
     if (periodNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in periodNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 periodIDRef = item.Attributes["id"].Name;
                 PeriodExtendedEnum ob = PeriodExtendedEnum();
                 IDManager.SetID(periodIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 periodIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 period = new PeriodExtendedEnum(item);
             }
         }
     }
     
 
 }
 public ReportSectionIdentification(XmlNode xmlNode)
 {
     XmlNodeList reportIdNodeList = xmlNode.SelectNodes("reportId");
     if (reportIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in reportIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reportIdIDRef = item.Attributes["id"].Name;
                 ReportId ob = ReportId();
                 IDManager.SetID(reportIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reportIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 reportId = new ReportId(item);
             }
         }
     }
     
 
     XmlNodeList sectionNumberNodeList = xmlNode.SelectNodes("sectionNumber");
     if (sectionNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sectionNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sectionNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sectionNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sectionNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sectionNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public CalculationFromObservation(XmlNode xmlNode)
 {
     XmlNodeList initialLevelNodeList = xmlNode.SelectNodes("initialLevel");
     if (initialLevelNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in initialLevelNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 initialLevelIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(initialLevelIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 initialLevelIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 initialLevel = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList closingLevelNodeList = xmlNode.SelectNodes("closingLevel");
     if (closingLevelNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in closingLevelNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 closingLevelIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(closingLevelIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 closingLevelIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 closingLevel = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList expiringLevelNodeList = xmlNode.SelectNodes("expiringLevel");
     if (expiringLevelNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expiringLevelNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expiringLevelIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(expiringLevelIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expiringLevelIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expiringLevel = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList expectedNNodeList = xmlNode.SelectNodes("expectedN");
     if (expectedNNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expectedNNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expectedNIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(expectedNIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expectedNIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expectedN = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public CalculationPeriod(XmlNode xmlNode)
 {
     XmlNodeList unadjustedStartDateNodeList = xmlNode.SelectNodes("unadjustedStartDate");
     if (unadjustedStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList unadjustedEndDateNodeList = xmlNode.SelectNodes("unadjustedEndDate");
     if (unadjustedEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in unadjustedEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 unadjustedEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(unadjustedEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 unadjustedEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 unadjustedEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedStartDateNodeList = xmlNode.SelectNodes("adjustedStartDate");
     if (adjustedStartDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedStartDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedStartDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedStartDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedStartDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedStartDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedEndDateNodeList = xmlNode.SelectNodes("adjustedEndDate");
     if (adjustedEndDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedEndDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedEndDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedEndDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedEndDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedEndDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");
     if (calculationPeriodNumberOfDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodNumberOfDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodNumberOfDays = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList notionalAmountNodeList = xmlNode.SelectNodes("notionalAmount");
     if (notionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalAmountIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(notionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notionalAmount = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList fxLinkedNotionalAmountNodeList = xmlNode.SelectNodes("fxLinkedNotionalAmount");
     if (fxLinkedNotionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxLinkedNotionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxLinkedNotionalAmountIDRef = item.Attributes["id"].Name;
                 FxLinkedNotionalAmount ob = FxLinkedNotionalAmount();
                 IDManager.SetID(fxLinkedNotionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxLinkedNotionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxLinkedNotionalAmount = new FxLinkedNotionalAmount(item);
             }
         }
     }
     
 
     XmlNodeList floatingRateDefinitionNodeList = xmlNode.SelectNodes("floatingRateDefinition");
     if (floatingRateDefinitionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in floatingRateDefinitionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 floatingRateDefinitionIDRef = item.Attributes["id"].Name;
                 FloatingRateDefinition ob = FloatingRateDefinition();
                 IDManager.SetID(floatingRateDefinitionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 floatingRateDefinitionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 floatingRateDefinition = new FloatingRateDefinition(item);
             }
         }
     }
     
 
     XmlNodeList fixedRateNodeList = xmlNode.SelectNodes("fixedRate");
     if (fixedRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixedRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixedRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(fixedRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixedRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixedRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList dayCountYearFractionNodeList = xmlNode.SelectNodes("dayCountYearFraction");
     if (dayCountYearFractionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayCountYearFractionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayCountYearFractionIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(dayCountYearFractionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayCountYearFractionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayCountYearFraction = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList forecastAmountNodeList = xmlNode.SelectNodes("forecastAmount");
     if (forecastAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastAmountIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(forecastAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastAmount = new Money(item);
             }
         }
     }
     
 
     XmlNodeList forecastRateNodeList = xmlNode.SelectNodes("forecastRate");
     if (forecastRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(forecastRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public NotificationMessage(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList headerNodeList = xmlNode.SelectNodes("header");
     if (headerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in headerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 headerIDRef = item.Attributes["id"].Name;
                 NotificationMessageHeader ob = NotificationMessageHeader();
                 IDManager.SetID(headerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 headerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 header = new NotificationMessageHeader(item);
             }
         }
     }
     
 
     XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");
     
     foreach (XmlNode item in validationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 validationIDRef = item.Attributes["id"].Name;
                 List<Validation> ob = new List<Validation>();
                 ob.Add(new Validation(item));
                 IDManager.SetID(validationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 validationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             validation.Add(new Validation(item));
             }
         }
     }
     
 
     XmlNodeList parentCorrelationIdNodeList = xmlNode.SelectNodes("parentCorrelationId");
     if (parentCorrelationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in parentCorrelationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(parentCorrelationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 parentCorrelationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 parentCorrelationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");
     if (correlationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(correlationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList onBehalfOfNodeList = xmlNode.SelectNodes("onBehalfOf");
     if (onBehalfOfNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in onBehalfOfNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 onBehalfOfIDRef = item.Attributes["id"].Name;
                 OnBehalfOf ob = OnBehalfOf();
                 IDManager.SetID(onBehalfOfIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 onBehalfOfIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 onBehalfOf = new OnBehalfOf(item);
             }
         }
     }
     
 
 }
 public PositionConstituent(XmlNode xmlNode)
 {
     XmlNodeList tradeNodeList = xmlNode.SelectNodes("trade");
     if (tradeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIDRef = item.Attributes["id"].Name;
                 Trade ob = Trade();
                 IDManager.SetID(tradeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 trade = new Trade(item);
             }
         }
     }
     
 
     XmlNodeList positionVersionReferenceNodeList = xmlNode.SelectNodes("positionVersionReference");
     if (positionVersionReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in positionVersionReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 positionVersionReferenceIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(positionVersionReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 positionVersionReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 positionVersionReference = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList tradeReferenceNodeList = xmlNode.SelectNodes("tradeReference");
     if (tradeReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeReferenceIDRef = item.Attributes["id"].Name;
                 PartyTradeIdentifiers ob = PartyTradeIdentifiers();
                 IDManager.SetID(tradeReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeReference = new PartyTradeIdentifiers(item);
             }
         }
     }
     
 
 }
 public ExchangeTradedContract(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList multiplierNodeList = xmlNode.SelectNodes("multiplier");
     if (multiplierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in multiplierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 multiplierIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(multiplierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 multiplierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 multiplier = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList contractReferenceNodeList = xmlNode.SelectNodes("contractReference");
     if (contractReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in contractReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 contractReferenceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(contractReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 contractReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 contractReference = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList expirationDateNodeList = xmlNode.SelectNodes("expirationDate");
     if (expirationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in expirationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 expirationDateIDRef = item.Attributes["id"].Name;
                 AdjustableOrRelativeDate ob = AdjustableOrRelativeDate();
                 IDManager.SetID(expirationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 expirationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 expirationDate = new AdjustableOrRelativeDate(item);
             }
         }
     }
     
 
 }
 public IntermediaryInformation(XmlNode xmlNode)
 {
     XmlNodeList routingIdsNodeList = xmlNode.SelectNodes("routingIds");
     if (routingIdsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in routingIdsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 routingIdsIDRef = item.Attributes["id"].Name;
                 RoutingIds ob = RoutingIds();
                 IDManager.SetID(routingIdsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 routingIdsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 routingIds = new RoutingIds(item);
             }
         }
     }
     
 
     XmlNodeList routingExplicitDetailsNodeList = xmlNode.SelectNodes("routingExplicitDetails");
     if (routingExplicitDetailsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in routingExplicitDetailsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 routingExplicitDetailsIDRef = item.Attributes["id"].Name;
                 RoutingExplicitDetails ob = RoutingExplicitDetails();
                 IDManager.SetID(routingExplicitDetailsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 routingExplicitDetailsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 routingExplicitDetails = new RoutingExplicitDetails(item);
             }
         }
     }
     
 
     XmlNodeList routingIdsAndExplicitDetailsNodeList = xmlNode.SelectNodes("routingIdsAndExplicitDetails");
     if (routingIdsAndExplicitDetailsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in routingIdsAndExplicitDetailsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 routingIdsAndExplicitDetailsIDRef = item.Attributes["id"].Name;
                 RoutingIdsAndExplicitDetails ob = RoutingIdsAndExplicitDetails();
                 IDManager.SetID(routingIdsAndExplicitDetailsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 routingIdsAndExplicitDetailsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 routingIdsAndExplicitDetails = new RoutingIdsAndExplicitDetails(item);
             }
         }
     }
     
 
     XmlNodeList intermediarySequenceNumberNodeList = xmlNode.SelectNodes("intermediarySequenceNumber");
     if (intermediarySequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in intermediarySequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 intermediarySequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(intermediarySequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 intermediarySequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 intermediarySequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList intermediaryPartyReferenceNodeList = xmlNode.SelectNodes("intermediaryPartyReference");
     if (intermediaryPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in intermediaryPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 intermediaryPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(intermediaryPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 intermediaryPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 intermediaryPartyReference = new PartyReference(item);
             }
         }
     }
     
 
 }
 public EventIdentifier(XmlNode xmlNode)
 {
     XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");
     if (correlationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(correlationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");
     if (tradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(tradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeIdentifier = new TradeIdentifier(item);
             }
         }
     }
     
 
 }
 public NonCorrectableRequestMessage(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList parentCorrelationIdNodeList = xmlNode.SelectNodes("parentCorrelationId");
     if (parentCorrelationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in parentCorrelationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(parentCorrelationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 parentCorrelationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 parentCorrelationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");
     if (correlationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(correlationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList onBehalfOfNodeList = xmlNode.SelectNodes("onBehalfOf");
     if (onBehalfOfNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in onBehalfOfNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 onBehalfOfIDRef = item.Attributes["id"].Name;
                 OnBehalfOf ob = OnBehalfOf();
                 IDManager.SetID(onBehalfOfIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 onBehalfOfIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 onBehalfOf = new OnBehalfOf(item);
             }
         }
     }
     
 
 }
 public RateObservation(XmlNode xmlNode)
 {
     XmlNodeList resetDateNodeList = xmlNode.SelectNodes("resetDate");
     if (resetDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in resetDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 resetDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(resetDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 resetDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 resetDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedFixingDateNodeList = xmlNode.SelectNodes("adjustedFixingDate");
     if (adjustedFixingDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedFixingDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedFixingDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedFixingDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedFixingDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedFixingDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList observedRateNodeList = xmlNode.SelectNodes("observedRate");
     if (observedRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observedRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observedRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(observedRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observedRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observedRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList treatedRateNodeList = xmlNode.SelectNodes("treatedRate");
     if (treatedRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in treatedRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 treatedRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(treatedRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 treatedRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 treatedRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList observationWeightNodeList = xmlNode.SelectNodes("observationWeight");
     if (observationWeightNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationWeightNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationWeightIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(observationWeightIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationWeightIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationWeight = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList rateReferenceNodeList = xmlNode.SelectNodes("rateReference");
     if (rateReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in rateReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 rateReferenceIDRef = item.Attributes["id"].Name;
                 RateReference ob = RateReference();
                 IDManager.SetID(rateReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 rateReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 rateReference = new RateReference(item);
             }
         }
     }
     
 
     XmlNodeList forecastRateNodeList = xmlNode.SelectNodes("forecastRate");
     if (forecastRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forecastRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forecastRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(forecastRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forecastRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forecastRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList treatedForecastRateNodeList = xmlNode.SelectNodes("treatedForecastRate");
     if (treatedForecastRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in treatedForecastRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 treatedForecastRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(treatedForecastRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 treatedForecastRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 treatedForecastRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
 }
 public PubliclyAvailableInformation(XmlNode xmlNode)
 {
     XmlNodeList standardPublicSourcesNodeList = xmlNode.SelectNodes("standardPublicSources");
     if (standardPublicSourcesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in standardPublicSourcesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 standardPublicSourcesIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(standardPublicSourcesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 standardPublicSourcesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 standardPublicSources = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList publicSourceNodeList = xmlNode.SelectNodes("publicSource");
     
     foreach (XmlNode item in publicSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 publicSourceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = new XsdTypeString();
                 ob.Add(new XsdTypeString(item));
                 IDManager.SetID(publicSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 publicSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             publicSource.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNodeList specifiedNumberNodeList = xmlNode.SelectNodes("specifiedNumber");
     if (specifiedNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in specifiedNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 specifiedNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(specifiedNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 specifiedNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 specifiedNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public CommodityPricingDates(XmlNode xmlNode)
 {
     XmlNodeList calculationPeriodsReferenceNodeList = xmlNode.SelectNodes("calculationPeriodsReference");
     if (calculationPeriodsReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodsReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodsReferenceIDRef = item.Attributes["id"].Name;
                 CalculationPeriodsReference ob = CalculationPeriodsReference();
                 IDManager.SetID(calculationPeriodsReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodsReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodsReference = new CalculationPeriodsReference(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodsScheduleReferenceNodeList = xmlNode.SelectNodes("calculationPeriodsScheduleReference");
     if (calculationPeriodsScheduleReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodsScheduleReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodsScheduleReferenceIDRef = item.Attributes["id"].Name;
                 CalculationPeriodsScheduleReference ob = CalculationPeriodsScheduleReference();
                 IDManager.SetID(calculationPeriodsScheduleReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodsScheduleReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodsScheduleReference = new CalculationPeriodsScheduleReference(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodsDatesReferenceNodeList = xmlNode.SelectNodes("calculationPeriodsDatesReference");
     if (calculationPeriodsDatesReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodsDatesReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodsDatesReferenceIDRef = item.Attributes["id"].Name;
                 CalculationPeriodsDatesReference ob = CalculationPeriodsDatesReference();
                 IDManager.SetID(calculationPeriodsDatesReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodsDatesReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodsDatesReference = new CalculationPeriodsDatesReference(item);
             }
         }
     }
     
 
     XmlNodeList lagNodeList = xmlNode.SelectNodes("lag");
     if (lagNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in lagNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 lagIDRef = item.Attributes["id"].Name;
                 Lag ob = Lag();
                 IDManager.SetID(lagIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 lagIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 lag = new Lag(item);
             }
         }
     }
     
 
     XmlNodeList dayTypeNodeList = xmlNode.SelectNodes("dayType");
     if (dayTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayTypeIDRef = item.Attributes["id"].Name;
                 CommodityDayTypeEnum ob = CommodityDayTypeEnum();
                 IDManager.SetID(dayTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayType = new CommodityDayTypeEnum(item);
             }
         }
     }
     
 
     XmlNodeList dayDistributionNodeList = xmlNode.SelectNodes("dayDistribution");
     if (dayDistributionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayDistributionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayDistributionIDRef = item.Attributes["id"].Name;
                 CommodityFrequencyType ob = CommodityFrequencyType();
                 IDManager.SetID(dayDistributionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayDistributionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayDistribution = new CommodityFrequencyType(item);
             }
         }
     }
     
 
     XmlNodeList dayCountNodeList = xmlNode.SelectNodes("dayCount");
     if (dayCountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayCountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayCountIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(dayCountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayCountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayCount = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList dayOfWeekNodeList = xmlNode.SelectNodes("dayOfWeek");
     
     foreach (XmlNode item in dayOfWeekNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayOfWeekIDRef = item.Attributes["id"].Name;
                 List<DayOfWeekEnum> ob = new List<DayOfWeekEnum>();
                 ob.Add(new DayOfWeekEnum(item));
                 IDManager.SetID(dayOfWeekIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayOfWeekIDRef = item.Attributes["href"].Name;
             }
             else
             {
             dayOfWeek.Add(new DayOfWeekEnum(item));
             }
         }
     }
     
 
     XmlNodeList dayNumberNodeList = xmlNode.SelectNodes("dayNumber");
     if (dayNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayNumberIDRef = item.Attributes["id"].Name;
                 XsdTypeInteger ob = XsdTypeInteger();
                 IDManager.SetID(dayNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayNumber = new XsdTypeInteger(item);
             }
         }
     }
     
 
     XmlNodeList businessCalendarNodeList = xmlNode.SelectNodes("businessCalendar");
     if (businessCalendarNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in businessCalendarNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 businessCalendarIDRef = item.Attributes["id"].Name;
                 CommodityBusinessCalendar ob = CommodityBusinessCalendar();
                 IDManager.SetID(businessCalendarIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 businessCalendarIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 businessCalendar = new CommodityBusinessCalendar(item);
             }
         }
     }
     
 
     XmlNodeList calendarSourceNodeList = xmlNode.SelectNodes("calendarSource");
     if (calendarSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calendarSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calendarSourceIDRef = item.Attributes["id"].Name;
                 CalendarSourceEnum ob = CalendarSourceEnum();
                 IDManager.SetID(calendarSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calendarSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calendarSource = new CalendarSourceEnum(item);
             }
         }
     }
     
 
     XmlNodeList settlementPeriodsNodeList = xmlNode.SelectNodes("settlementPeriods");
     
     foreach (XmlNode item in settlementPeriodsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementPeriodsIDRef = item.Attributes["id"].Name;
                 List<SettlementPeriods> ob = new List<SettlementPeriods>();
                 ob.Add(new SettlementPeriods(item));
                 IDManager.SetID(settlementPeriodsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementPeriodsIDRef = item.Attributes["href"].Name;
             }
             else
             {
             settlementPeriods.Add(new SettlementPeriods(item));
             }
         }
     }
     
 
     XmlNodeList settlementPeriodsReferenceNodeList = xmlNode.SelectNodes("settlementPeriodsReference");
     
     foreach (XmlNode item in settlementPeriodsReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settlementPeriodsReferenceIDRef = item.Attributes["id"].Name;
                 List<SettlementPeriodsReference> ob = new List<SettlementPeriodsReference>();
                 ob.Add(new SettlementPeriodsReference(item));
                 IDManager.SetID(settlementPeriodsReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settlementPeriodsReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             settlementPeriodsReference.Add(new SettlementPeriodsReference(item));
             }
         }
     }
     
 
     XmlNodeList pricingDatesNodeList = xmlNode.SelectNodes("pricingDates");
     
     foreach (XmlNode item in pricingDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 pricingDatesIDRef = item.Attributes["id"].Name;
                 List<AdjustableDates> ob = new List<AdjustableDates>();
                 ob.Add(new AdjustableDates(item));
                 IDManager.SetID(pricingDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 pricingDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
             pricingDates.Add(new AdjustableDates(item));
             }
         }
     }
     
 
 }
 public WeightedAveragingObservation(XmlNode xmlNode)
 {
     XmlNodeList dateTimeNodeList = xmlNode.SelectNodes("dateTime");
     if (dateTimeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dateTimeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dateTimeIDRef = item.Attributes["id"].Name;
                 XsdTypeDateTime ob = XsdTypeDateTime();
                 IDManager.SetID(dateTimeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dateTimeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dateTime = new XsdTypeDateTime(item);
             }
         }
     }
     
 
     XmlNodeList observationNumberNodeList = xmlNode.SelectNodes("observationNumber");
     if (observationNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in observationNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 observationNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(observationNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 observationNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 observationNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList weightNodeList = xmlNode.SelectNodes("weight");
     if (weightNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in weightNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 weightIDRef = item.Attributes["id"].Name;
                 NonNegativeDecimal ob = NonNegativeDecimal();
                 IDManager.SetID(weightIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 weightIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 weight = new NonNegativeDecimal(item);
             }
         }
     }
     
 
 }
Ejemplo n.º 22
0
 public Fra(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList buyerPartyReferenceNodeList = xmlNode.SelectNodes("buyerPartyReference");
     if (buyerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in buyerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 buyerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(buyerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 buyerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 buyerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList buyerAccountReferenceNodeList = xmlNode.SelectNodes("buyerAccountReference");
     if (buyerAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in buyerAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 buyerAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(buyerAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 buyerAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 buyerAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList sellerPartyReferenceNodeList = xmlNode.SelectNodes("sellerPartyReference");
     if (sellerPartyReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sellerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sellerPartyReferenceIDRef = item.Attributes["id"].Name;
                 PartyReference ob = PartyReference();
                 IDManager.SetID(sellerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sellerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sellerPartyReference = new PartyReference(item);
             }
         }
     }
     
 
     XmlNodeList sellerAccountReferenceNodeList = xmlNode.SelectNodes("sellerAccountReference");
     if (sellerAccountReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sellerAccountReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sellerAccountReferenceIDRef = item.Attributes["id"].Name;
                 AccountReference ob = AccountReference();
                 IDManager.SetID(sellerAccountReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sellerAccountReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sellerAccountReference = new AccountReference(item);
             }
         }
     }
     
 
     XmlNodeList adjustedEffectiveDateNodeList = xmlNode.SelectNodes("adjustedEffectiveDate");
     if (adjustedEffectiveDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedEffectiveDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedEffectiveDateIDRef = item.Attributes["id"].Name;
                 RequiredIdentifierDate ob = RequiredIdentifierDate();
                 IDManager.SetID(adjustedEffectiveDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedEffectiveDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedEffectiveDate = new RequiredIdentifierDate(item);
             }
         }
     }
     
 
     XmlNodeList adjustedTerminationDateNodeList = xmlNode.SelectNodes("adjustedTerminationDate");
     if (adjustedTerminationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in adjustedTerminationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 adjustedTerminationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(adjustedTerminationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 adjustedTerminationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 adjustedTerminationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList paymentDateNodeList = xmlNode.SelectNodes("paymentDate");
     if (paymentDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in paymentDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 paymentDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(paymentDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 paymentDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 paymentDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList fixingDateOffsetNodeList = xmlNode.SelectNodes("fixingDateOffset");
     if (fixingDateOffsetNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixingDateOffsetNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixingDateOffsetIDRef = item.Attributes["id"].Name;
                 RelativeDateOffset ob = RelativeDateOffset();
                 IDManager.SetID(fixingDateOffsetIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixingDateOffsetIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixingDateOffset = new RelativeDateOffset(item);
             }
         }
     }
     
 
     XmlNodeList dayCountFractionNodeList = xmlNode.SelectNodes("dayCountFraction");
     if (dayCountFractionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dayCountFractionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dayCountFractionIDRef = item.Attributes["id"].Name;
                 DayCountFraction ob = DayCountFraction();
                 IDManager.SetID(dayCountFractionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dayCountFractionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dayCountFraction = new DayCountFraction(item);
             }
         }
     }
     
 
     XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");
     if (calculationPeriodNumberOfDaysNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationPeriodNumberOfDaysNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationPeriodNumberOfDaysIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationPeriodNumberOfDays = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList notionalNodeList = xmlNode.SelectNodes("notional");
     if (notionalNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalIDRef = item.Attributes["id"].Name;
                 Money ob = Money();
                 IDManager.SetID(notionalIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notional = new Money(item);
             }
         }
     }
     
 
     XmlNodeList fixedRateNodeList = xmlNode.SelectNodes("fixedRate");
     if (fixedRateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fixedRateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fixedRateIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(fixedRateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fixedRateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fixedRate = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList floatingRateIndexNodeList = xmlNode.SelectNodes("floatingRateIndex");
     if (floatingRateIndexNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in floatingRateIndexNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 floatingRateIndexIDRef = item.Attributes["id"].Name;
                 FloatingRateIndex ob = FloatingRateIndex();
                 IDManager.SetID(floatingRateIndexIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 floatingRateIndexIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 floatingRateIndex = new FloatingRateIndex(item);
             }
         }
     }
     
 
     XmlNodeList indexTenorNodeList = xmlNode.SelectNodes("indexTenor");
     
     foreach (XmlNode item in indexTenorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexTenorIDRef = item.Attributes["id"].Name;
                 List<Period> ob = new List<Period>();
                 ob.Add(new Period(item));
                 IDManager.SetID(indexTenorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexTenorIDRef = item.Attributes["href"].Name;
             }
             else
             {
             indexTenor.Add(new Period(item));
             }
         }
     }
     
 
     XmlNodeList fraDiscountingNodeList = xmlNode.SelectNodes("fraDiscounting");
     if (fraDiscountingNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fraDiscountingNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fraDiscountingIDRef = item.Attributes["id"].Name;
                 FraDiscountingEnum ob = FraDiscountingEnum();
                 IDManager.SetID(fraDiscountingIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fraDiscountingIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fraDiscounting = new FraDiscountingEnum(item);
             }
         }
     }
     
 
 }
 public Position(XmlNode xmlNode)
 {
     XmlNodeList positionIdNodeList = xmlNode.SelectNodes("positionId");
     if (positionIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in positionIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 positionIdIDRef = item.Attributes["id"].Name;
                 PositionId ob = PositionId();
                 IDManager.SetID(positionIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 positionIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 positionId = new PositionId(item);
             }
         }
     }
     
 
     XmlNodeList versionNodeList = xmlNode.SelectNodes("version");
     if (versionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in versionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 versionIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(versionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 versionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 version = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList statusNodeList = xmlNode.SelectNodes("status");
     if (statusNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in statusNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 statusIDRef = item.Attributes["id"].Name;
                 PositionStatusEnum ob = PositionStatusEnum();
                 IDManager.SetID(statusIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 statusIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 status = new PositionStatusEnum(item);
             }
         }
     }
     
 
     XmlNodeList creationDateNodeList = xmlNode.SelectNodes("creationDate");
     if (creationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creationDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(creationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creationDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList originatingEventNodeList = xmlNode.SelectNodes("originatingEvent");
     if (originatingEventNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in originatingEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originatingEventIDRef = item.Attributes["id"].Name;
                 PositionOriginEnum ob = PositionOriginEnum();
                 IDManager.SetID(originatingEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originatingEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 originatingEvent = new PositionOriginEnum(item);
             }
         }
     }
     
 
     XmlNodeList historyNodeList = xmlNode.SelectNodes("history");
     if (historyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in historyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 historyIDRef = item.Attributes["id"].Name;
                 PositionHistory ob = PositionHistory();
                 IDManager.SetID(historyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 historyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 history = new PositionHistory(item);
             }
         }
     }
     
 
     XmlNodeList reportingRolesNodeList = xmlNode.SelectNodes("reportingRoles");
     if (reportingRolesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in reportingRolesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reportingRolesIDRef = item.Attributes["id"].Name;
                 ReportingRoles ob = ReportingRoles();
                 IDManager.SetID(reportingRolesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reportingRolesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 reportingRoles = new ReportingRoles(item);
             }
         }
     }
     
 
     XmlNodeList constituentNodeList = xmlNode.SelectNodes("constituent");
     if (constituentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in constituentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 constituentIDRef = item.Attributes["id"].Name;
                 PositionConstituent ob = PositionConstituent();
                 IDManager.SetID(constituentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 constituentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 constituent = new PositionConstituent(item);
             }
         }
     }
     
 
     XmlNodeList scheduledDateNodeList = xmlNode.SelectNodes("scheduledDate");
     
     foreach (XmlNode item in scheduledDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 scheduledDateIDRef = item.Attributes["id"].Name;
                 List<ScheduledDate> ob = new List<ScheduledDate>();
                 ob.Add(new ScheduledDate(item));
                 IDManager.SetID(scheduledDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 scheduledDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
             scheduledDate.Add(new ScheduledDate(item));
             }
         }
     }
     
 
     XmlNodeList valuationNodeList = xmlNode.SelectNodes("valuation");
     
     foreach (XmlNode item in valuationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationIDRef = item.Attributes["id"].Name;
                 List<AssetValuation> ob = new List<AssetValuation>();
                 ob.Add(new AssetValuation(item));
                 IDManager.SetID(valuationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             valuation.Add(new AssetValuation(item));
             }
         }
     }
     
 
 }
 public BasketReferenceInformation(XmlNode xmlNode)
 {
     XmlNodeList basketNameNodeList = xmlNode.SelectNodes("basketName");
     if (basketNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in basketNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 basketNameIDRef = item.Attributes["id"].Name;
                 BasketName ob = BasketName();
                 IDManager.SetID(basketNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 basketNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 basketName = new BasketName(item);
             }
         }
     }
     
 
     XmlNodeList basketIdNodeList = xmlNode.SelectNodes("basketId");
     
     foreach (XmlNode item in basketIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 basketIdIDRef = item.Attributes["id"].Name;
                 List<BasketId> ob = new List<BasketId>();
                 ob.Add(new BasketId(item));
                 IDManager.SetID(basketIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 basketIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             basketId.Add(new BasketId(item));
             }
         }
     }
     
 
     XmlNodeList referencePoolNodeList = xmlNode.SelectNodes("referencePool");
     if (referencePoolNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in referencePoolNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 referencePoolIDRef = item.Attributes["id"].Name;
                 ReferencePool ob = ReferencePool();
                 IDManager.SetID(referencePoolIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 referencePoolIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 referencePool = new ReferencePool(item);
             }
         }
     }
     
 
     XmlNodeList nthToDefaultNodeList = xmlNode.SelectNodes("nthToDefault");
     if (nthToDefaultNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nthToDefaultNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nthToDefaultIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(nthToDefaultIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nthToDefaultIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nthToDefault = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList mthToDefaultNodeList = xmlNode.SelectNodes("mthToDefault");
     if (mthToDefaultNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mthToDefaultNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mthToDefaultIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(mthToDefaultIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mthToDefaultIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mthToDefault = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList trancheNodeList = xmlNode.SelectNodes("tranche");
     if (trancheNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in trancheNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 trancheIDRef = item.Attributes["id"].Name;
                 Tranche ob = Tranche();
                 IDManager.SetID(trancheIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 trancheIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tranche = new Tranche(item);
             }
         }
     }
     
 
 }
 public IndexReferenceInformation(XmlNode xmlNode)
 {
     XmlNodeList indexNameNodeList = xmlNode.SelectNodes("indexName");
     if (indexNameNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexNameNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexNameIDRef = item.Attributes["id"].Name;
                 IndexName ob = IndexName();
                 IDManager.SetID(indexNameIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexNameIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexName = new IndexName(item);
             }
         }
     }
     
 
     XmlNodeList indexIdNodeList = xmlNode.SelectNodes("indexId");
     
     foreach (XmlNode item in indexIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexIdIDRef = item.Attributes["id"].Name;
                 List<IndexId> ob = new List<IndexId>();
                 ob.Add(new IndexId(item));
                 IDManager.SetID(indexIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             indexId.Add(new IndexId(item));
             }
         }
     }
     
 
     XmlNodeList indexSeriesNodeList = xmlNode.SelectNodes("indexSeries");
     if (indexSeriesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexSeriesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexSeriesIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(indexSeriesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexSeriesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexSeries = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList indexAnnexVersionNodeList = xmlNode.SelectNodes("indexAnnexVersion");
     if (indexAnnexVersionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexAnnexVersionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexAnnexVersionIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(indexAnnexVersionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexAnnexVersionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexAnnexVersion = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList indexAnnexDateNodeList = xmlNode.SelectNodes("indexAnnexDate");
     if (indexAnnexDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexAnnexDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexAnnexDateIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(indexAnnexDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexAnnexDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexAnnexDate = new XsdTypeDate(item);
             }
         }
     }
     
 
     XmlNodeList indexAnnexSourceNodeList = xmlNode.SelectNodes("indexAnnexSource");
     if (indexAnnexSourceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in indexAnnexSourceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 indexAnnexSourceIDRef = item.Attributes["id"].Name;
                 IndexAnnexSource ob = IndexAnnexSource();
                 IDManager.SetID(indexAnnexSourceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 indexAnnexSourceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 indexAnnexSource = new IndexAnnexSource(item);
             }
         }
     }
     
 
     XmlNodeList excludedReferenceEntityNodeList = xmlNode.SelectNodes("excludedReferenceEntity");
     
     foreach (XmlNode item in excludedReferenceEntityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 excludedReferenceEntityIDRef = item.Attributes["id"].Name;
                 List<LegalEntity> ob = new List<LegalEntity>();
                 ob.Add(new LegalEntity(item));
                 IDManager.SetID(excludedReferenceEntityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 excludedReferenceEntityIDRef = item.Attributes["href"].Name;
             }
             else
             {
             excludedReferenceEntity.Add(new LegalEntity(item));
             }
         }
     }
     
 
     XmlNodeList trancheNodeList = xmlNode.SelectNodes("tranche");
     if (trancheNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in trancheNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 trancheIDRef = item.Attributes["id"].Name;
                 Tranche ob = Tranche();
                 IDManager.SetID(trancheIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 trancheIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tranche = new Tranche(item);
             }
         }
     }
     
 
     XmlNodeList settledEntityMatrixNodeList = xmlNode.SelectNodes("settledEntityMatrix");
     if (settledEntityMatrixNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in settledEntityMatrixNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 settledEntityMatrixIDRef = item.Attributes["id"].Name;
                 SettledEntityMatrix ob = SettledEntityMatrix();
                 IDManager.SetID(settledEntityMatrixIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 settledEntityMatrixIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 settledEntityMatrix = new SettledEntityMatrix(item);
             }
         }
     }
     
 
 }
 public CommodityMarketDisruption(XmlNode xmlNode)
 {
     XmlNodeList marketDisruptionEventsNodeList = xmlNode.SelectNodes("marketDisruptionEvents");
     if (marketDisruptionEventsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in marketDisruptionEventsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 marketDisruptionEventsIDRef = item.Attributes["id"].Name;
                 MarketDisruptionEventsEnum ob = MarketDisruptionEventsEnum();
                 IDManager.SetID(marketDisruptionEventsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 marketDisruptionEventsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 marketDisruptionEvents = new MarketDisruptionEventsEnum(item);
             }
         }
     }
     
 
     XmlNodeList additionalMarketDisruptionEventNodeList = xmlNode.SelectNodes("additionalMarketDisruptionEvent");
     
     foreach (XmlNode item in additionalMarketDisruptionEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 additionalMarketDisruptionEventIDRef = item.Attributes["id"].Name;
                 List<MarketDisruptionEvent> ob = new List<MarketDisruptionEvent>();
                 ob.Add(new MarketDisruptionEvent(item));
                 IDManager.SetID(additionalMarketDisruptionEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 additionalMarketDisruptionEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
             additionalMarketDisruptionEvent.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNodeList marketDisruptionEventNodeList = xmlNode.SelectNodes("marketDisruptionEvent");
     
     foreach (XmlNode item in marketDisruptionEventNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 marketDisruptionEventIDRef = item.Attributes["id"].Name;
                 List<MarketDisruptionEvent> ob = new List<MarketDisruptionEvent>();
                 ob.Add(new MarketDisruptionEvent(item));
                 IDManager.SetID(marketDisruptionEventIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 marketDisruptionEventIDRef = item.Attributes["href"].Name;
             }
             else
             {
             marketDisruptionEvent.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNodeList disruptionFallbacksNodeList = xmlNode.SelectNodes("disruptionFallbacks");
     if (disruptionFallbacksNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in disruptionFallbacksNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 disruptionFallbacksIDRef = item.Attributes["id"].Name;
                 DisruptionFallbacksEnum ob = DisruptionFallbacksEnum();
                 IDManager.SetID(disruptionFallbacksIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 disruptionFallbacksIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 disruptionFallbacks = new DisruptionFallbacksEnum(item);
             }
         }
     }
     
 
     XmlNodeList disruptionFallbackNodeList = xmlNode.SelectNodes("disruptionFallback");
     
     foreach (XmlNode item in disruptionFallbackNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 disruptionFallbackIDRef = item.Attributes["id"].Name;
                 List<SequencedDisruptionFallback> ob = new List<SequencedDisruptionFallback>();
                 ob.Add(new SequencedDisruptionFallback(item));
                 IDManager.SetID(disruptionFallbackIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 disruptionFallbackIDRef = item.Attributes["href"].Name;
             }
             else
             {
             disruptionFallback.Add(new SequencedDisruptionFallback(item));
             }
         }
     }
     
 
     XmlNodeList fallbackReferencePriceNodeList = xmlNode.SelectNodes("fallbackReferencePrice");
     if (fallbackReferencePriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fallbackReferencePriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fallbackReferencePriceIDRef = item.Attributes["id"].Name;
                 Underlyer ob = Underlyer();
                 IDManager.SetID(fallbackReferencePriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fallbackReferencePriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fallbackReferencePrice = new Underlyer(item);
             }
         }
     }
     
 
     XmlNodeList maximumNumberOfDaysOfDisruptionNodeList = xmlNode.SelectNodes("maximumNumberOfDaysOfDisruption");
     if (maximumNumberOfDaysOfDisruptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maximumNumberOfDaysOfDisruptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["id"].Name;
                 XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                 IDManager.SetID(maximumNumberOfDaysOfDisruptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maximumNumberOfDaysOfDisruption = new XsdTypeNonNegativeInteger(item);
             }
         }
     }
     
 
     XmlNodeList priceMaterialityPercentageNodeList = xmlNode.SelectNodes("priceMaterialityPercentage");
     if (priceMaterialityPercentageNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in priceMaterialityPercentageNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 priceMaterialityPercentageIDRef = item.Attributes["id"].Name;
                 XsdTypeDecimal ob = XsdTypeDecimal();
                 IDManager.SetID(priceMaterialityPercentageIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 priceMaterialityPercentageIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 priceMaterialityPercentage = new XsdTypeDecimal(item);
             }
         }
     }
     
 
     XmlNodeList minimumFuturesContractsNodeList = xmlNode.SelectNodes("minimumFuturesContracts");
     if (minimumFuturesContractsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in minimumFuturesContractsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 minimumFuturesContractsIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(minimumFuturesContractsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 minimumFuturesContractsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 minimumFuturesContracts = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public Exception(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList headerNodeList = xmlNode.SelectNodes("header");
     if (headerNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in headerNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 headerIDRef = item.Attributes["id"].Name;
                 ExceptionMessageHeader ob = ExceptionMessageHeader();
                 IDManager.SetID(headerIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 headerIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 header = new ExceptionMessageHeader(item);
             }
         }
     }
     
 
     XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");
     
     foreach (XmlNode item in validationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 validationIDRef = item.Attributes["id"].Name;
                 List<Validation> ob = new List<Validation>();
                 ob.Add(new Validation(item));
                 IDManager.SetID(validationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 validationIDRef = item.Attributes["href"].Name;
             }
             else
             {
             validation.Add(new Validation(item));
             }
         }
     }
     
 
     XmlNodeList parentCorrelationIdNodeList = xmlNode.SelectNodes("parentCorrelationId");
     if (parentCorrelationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in parentCorrelationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(parentCorrelationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 parentCorrelationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 parentCorrelationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");
     if (correlationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(correlationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList reasonNodeList = xmlNode.SelectNodes("reason");
     
     foreach (XmlNode item in reasonNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 reasonIDRef = item.Attributes["id"].Name;
                 List<Reason> ob = new List<Reason>();
                 ob.Add(new Reason(item));
                 IDManager.SetID(reasonIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 reasonIDRef = item.Attributes["href"].Name;
             }
             else
             {
             reason.Add(new Reason(item));
             }
         }
     }
     
 
     XmlNodeList additionalDataNodeList = xmlNode.SelectNodes("additionalData");
     if (additionalDataNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in additionalDataNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 additionalDataIDRef = item.Attributes["id"].Name;
                 AdditionalData ob = AdditionalData();
                 IDManager.SetID(additionalDataIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 additionalDataIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 additionalData = new AdditionalData(item);
             }
         }
     }
     
 
 }
 public Correlation(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList notionalAmountNodeList = xmlNode.SelectNodes("notionalAmount");
     if (notionalAmountNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in notionalAmountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 notionalAmountIDRef = item.Attributes["id"].Name;
                 NonNegativeMoney ob = NonNegativeMoney();
                 IDManager.SetID(notionalAmountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 notionalAmountIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 notionalAmount = new NonNegativeMoney(item);
             }
         }
     }
     
 
     XmlNodeList correlationStrikePriceNodeList = xmlNode.SelectNodes("correlationStrikePrice");
     if (correlationStrikePriceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationStrikePriceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationStrikePriceIDRef = item.Attributes["id"].Name;
                 CorrelationValue ob = CorrelationValue();
                 IDManager.SetID(correlationStrikePriceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationStrikePriceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationStrikePrice = new CorrelationValue(item);
             }
         }
     }
     
 
     XmlNodeList boundedCorrelationNodeList = xmlNode.SelectNodes("boundedCorrelation");
     if (boundedCorrelationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in boundedCorrelationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 boundedCorrelationIDRef = item.Attributes["id"].Name;
                 BoundedCorrelation ob = BoundedCorrelation();
                 IDManager.SetID(boundedCorrelationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 boundedCorrelationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 boundedCorrelation = new BoundedCorrelation(item);
             }
         }
     }
     
 
     XmlNodeList numberOfDataSeriesNodeList = xmlNode.SelectNodes("numberOfDataSeries");
     if (numberOfDataSeriesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in numberOfDataSeriesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 numberOfDataSeriesIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(numberOfDataSeriesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 numberOfDataSeriesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 numberOfDataSeries = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
 }
 public Future(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList multiplierNodeList = xmlNode.SelectNodes("multiplier");
     if (multiplierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in multiplierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 multiplierIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(multiplierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 multiplierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 multiplier = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList futureContractReferenceNodeList = xmlNode.SelectNodes("futureContractReference");
     if (futureContractReferenceNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in futureContractReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 futureContractReferenceIDRef = item.Attributes["id"].Name;
                 XsdTypeString ob = XsdTypeString();
                 IDManager.SetID(futureContractReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 futureContractReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 futureContractReference = new XsdTypeString(item);
             }
         }
     }
     
 
     XmlNodeList maturityNodeList = xmlNode.SelectNodes("maturity");
     if (maturityNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in maturityNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 maturityIDRef = item.Attributes["id"].Name;
                 XsdTypeDate ob = XsdTypeDate();
                 IDManager.SetID(maturityIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 maturityIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 maturity = new XsdTypeDate(item);
             }
         }
     }
     
 
 }