public Trade(XmlNode xmlNode)
 {
     XmlNode tradeHeaderNode = xmlNode.SelectSingleNode("tradeHeader");
     
     if (tradeHeaderNode != null)
     {
         if (tradeHeaderNode.Attributes["href"] != null || tradeHeaderNode.Attributes["id"] != null) 
         {
             if (tradeHeaderNode.Attributes["id"] != null) 
             {
                 tradeHeaderIDRef_ = tradeHeaderNode.Attributes["id"].Value;
                 TradeHeader ob = new TradeHeader(tradeHeaderNode);
                 IDManager.SetID(tradeHeaderIDRef_, ob);
             }
             else if (tradeHeaderNode.Attributes["href"] != null)
             {
                 tradeHeaderIDRef_ = tradeHeaderNode.Attributes["href"].Value;
             }
             else
             {
                 tradeHeader_ = new TradeHeader(tradeHeaderNode);
             }
         }
         else
         {
             tradeHeader_ = new TradeHeader(tradeHeaderNode);
         }
     }
     
 
     XmlNode productNode = xmlNode.SelectSingleNode("product");
     
     if (productNode != null)
     {
         if (productNode.Attributes["href"] != null || productNode.Attributes["id"] != null) 
         {
             if (productNode.Attributes["id"] != null) 
             {
                 productIDRef_ = productNode.Attributes["id"].Value;
                 Product ob = new Product(productNode);
                 IDManager.SetID(productIDRef_, ob);
             }
             else if (productNode.Attributes["href"] != null)
             {
                 productIDRef_ = productNode.Attributes["href"].Value;
             }
             else
             {
                 product_ = new Product(productNode);
             }
         }
         else
         {
             product_ = new Product(productNode);
         }
     }
     
 
     XmlNode forwardNode = xmlNode.SelectSingleNode("forward");
     
     if (forwardNode != null)
     {
         if (forwardNode.Attributes["href"] != null || forwardNode.Attributes["id"] != null) 
         {
             if (forwardNode.Attributes["id"] != null) 
             {
                 forwardIDRef_ = forwardNode.Attributes["id"].Value;
                 ForwardSale ob = new ForwardSale(forwardNode);
                 IDManager.SetID(forwardIDRef_, ob);
             }
             else if (forwardNode.Attributes["href"] != null)
             {
                 forwardIDRef_ = forwardNode.Attributes["href"].Value;
             }
             else
             {
                 forward_ = new ForwardSale(forwardNode);
             }
         }
         else
         {
             forward_ = new ForwardSale(forwardNode);
         }
     }
     
 
     XmlNode bondOptionNode = xmlNode.SelectSingleNode("bondOption");
     
     if (bondOptionNode != null)
     {
         if (bondOptionNode.Attributes["href"] != null || bondOptionNode.Attributes["id"] != null) 
         {
             if (bondOptionNode.Attributes["id"] != null) 
             {
                 bondOptionIDRef_ = bondOptionNode.Attributes["id"].Value;
                 BondOption ob = new BondOption(bondOptionNode);
                 IDManager.SetID(bondOptionIDRef_, ob);
             }
             else if (bondOptionNode.Attributes["href"] != null)
             {
                 bondOptionIDRef_ = bondOptionNode.Attributes["href"].Value;
             }
             else
             {
                 bondOption_ = new BondOption(bondOptionNode);
             }
         }
         else
         {
             bondOption_ = new BondOption(bondOptionNode);
         }
     }
     
 
     XmlNode creditDefaultSwapNode = xmlNode.SelectSingleNode("creditDefaultSwap");
     
     if (creditDefaultSwapNode != null)
     {
         if (creditDefaultSwapNode.Attributes["href"] != null || creditDefaultSwapNode.Attributes["id"] != null) 
         {
             if (creditDefaultSwapNode.Attributes["id"] != null) 
             {
                 creditDefaultSwapIDRef_ = creditDefaultSwapNode.Attributes["id"].Value;
                 CreditDefaultSwap ob = new CreditDefaultSwap(creditDefaultSwapNode);
                 IDManager.SetID(creditDefaultSwapIDRef_, ob);
             }
             else if (creditDefaultSwapNode.Attributes["href"] != null)
             {
                 creditDefaultSwapIDRef_ = creditDefaultSwapNode.Attributes["href"].Value;
             }
             else
             {
                 creditDefaultSwap_ = new CreditDefaultSwap(creditDefaultSwapNode);
             }
         }
         else
         {
             creditDefaultSwap_ = new CreditDefaultSwap(creditDefaultSwapNode);
         }
     }
     
 
     XmlNode creditDefaultSwapOptionNode = xmlNode.SelectSingleNode("creditDefaultSwapOption");
     
     if (creditDefaultSwapOptionNode != null)
     {
         if (creditDefaultSwapOptionNode.Attributes["href"] != null || creditDefaultSwapOptionNode.Attributes["id"] != null) 
         {
             if (creditDefaultSwapOptionNode.Attributes["id"] != null) 
             {
                 creditDefaultSwapOptionIDRef_ = creditDefaultSwapOptionNode.Attributes["id"].Value;
                 CreditDefaultSwapOption ob = new CreditDefaultSwapOption(creditDefaultSwapOptionNode);
                 IDManager.SetID(creditDefaultSwapOptionIDRef_, ob);
             }
             else if (creditDefaultSwapOptionNode.Attributes["href"] != null)
             {
                 creditDefaultSwapOptionIDRef_ = creditDefaultSwapOptionNode.Attributes["href"].Value;
             }
             else
             {
                 creditDefaultSwapOption_ = new CreditDefaultSwapOption(creditDefaultSwapOptionNode);
             }
         }
         else
         {
             creditDefaultSwapOption_ = new CreditDefaultSwapOption(creditDefaultSwapOptionNode);
         }
     }
     
 
     XmlNode commodityForwardNode = xmlNode.SelectSingleNode("commodityForward");
     
     if (commodityForwardNode != null)
     {
         if (commodityForwardNode.Attributes["href"] != null || commodityForwardNode.Attributes["id"] != null) 
         {
             if (commodityForwardNode.Attributes["id"] != null) 
             {
                 commodityForwardIDRef_ = commodityForwardNode.Attributes["id"].Value;
                 CommodityForward ob = new CommodityForward(commodityForwardNode);
                 IDManager.SetID(commodityForwardIDRef_, ob);
             }
             else if (commodityForwardNode.Attributes["href"] != null)
             {
                 commodityForwardIDRef_ = commodityForwardNode.Attributes["href"].Value;
             }
             else
             {
                 commodityForward_ = new CommodityForward(commodityForwardNode);
             }
         }
         else
         {
             commodityForward_ = new CommodityForward(commodityForwardNode);
         }
     }
     
 
     XmlNode commodityOptionNode = xmlNode.SelectSingleNode("commodityOption");
     
     if (commodityOptionNode != null)
     {
         if (commodityOptionNode.Attributes["href"] != null || commodityOptionNode.Attributes["id"] != null) 
         {
             if (commodityOptionNode.Attributes["id"] != null) 
             {
                 commodityOptionIDRef_ = commodityOptionNode.Attributes["id"].Value;
                 CommodityOption ob = new CommodityOption(commodityOptionNode);
                 IDManager.SetID(commodityOptionIDRef_, ob);
             }
             else if (commodityOptionNode.Attributes["href"] != null)
             {
                 commodityOptionIDRef_ = commodityOptionNode.Attributes["href"].Value;
             }
             else
             {
                 commodityOption_ = new CommodityOption(commodityOptionNode);
             }
         }
         else
         {
             commodityOption_ = new CommodityOption(commodityOptionNode);
         }
     }
     
 
     XmlNode commoditySwapNode = xmlNode.SelectSingleNode("commoditySwap");
     
     if (commoditySwapNode != null)
     {
         if (commoditySwapNode.Attributes["href"] != null || commoditySwapNode.Attributes["id"] != null) 
         {
             if (commoditySwapNode.Attributes["id"] != null) 
             {
                 commoditySwapIDRef_ = commoditySwapNode.Attributes["id"].Value;
                 CommoditySwap ob = new CommoditySwap(commoditySwapNode);
                 IDManager.SetID(commoditySwapIDRef_, ob);
             }
             else if (commoditySwapNode.Attributes["href"] != null)
             {
                 commoditySwapIDRef_ = commoditySwapNode.Attributes["href"].Value;
             }
             else
             {
                 commoditySwap_ = new CommoditySwap(commoditySwapNode);
             }
         }
         else
         {
             commoditySwap_ = new CommoditySwap(commoditySwapNode);
         }
     }
     
 
     XmlNode commoditySwaptionNode = xmlNode.SelectSingleNode("commoditySwaption");
     
     if (commoditySwaptionNode != null)
     {
         if (commoditySwaptionNode.Attributes["href"] != null || commoditySwaptionNode.Attributes["id"] != null) 
         {
             if (commoditySwaptionNode.Attributes["id"] != null) 
             {
                 commoditySwaptionIDRef_ = commoditySwaptionNode.Attributes["id"].Value;
                 CommoditySwaption ob = new CommoditySwaption(commoditySwaptionNode);
                 IDManager.SetID(commoditySwaptionIDRef_, ob);
             }
             else if (commoditySwaptionNode.Attributes["href"] != null)
             {
                 commoditySwaptionIDRef_ = commoditySwaptionNode.Attributes["href"].Value;
             }
             else
             {
                 commoditySwaption_ = new CommoditySwaption(commoditySwaptionNode);
             }
         }
         else
         {
             commoditySwaption_ = new CommoditySwaption(commoditySwaptionNode);
         }
     }
     
 
     XmlNode correlationSwapNode = xmlNode.SelectSingleNode("correlationSwap");
     
     if (correlationSwapNode != null)
     {
         if (correlationSwapNode.Attributes["href"] != null || correlationSwapNode.Attributes["id"] != null) 
         {
             if (correlationSwapNode.Attributes["id"] != null) 
             {
                 correlationSwapIDRef_ = correlationSwapNode.Attributes["id"].Value;
                 CorrelationSwap ob = new CorrelationSwap(correlationSwapNode);
                 IDManager.SetID(correlationSwapIDRef_, ob);
             }
             else if (correlationSwapNode.Attributes["href"] != null)
             {
                 correlationSwapIDRef_ = correlationSwapNode.Attributes["href"].Value;
             }
             else
             {
                 correlationSwap_ = new CorrelationSwap(correlationSwapNode);
             }
         }
         else
         {
             correlationSwap_ = new CorrelationSwap(correlationSwapNode);
         }
     }
     
 
     XmlNode dividendSwapOptionTransactionSupplementNode = xmlNode.SelectSingleNode("dividendSwapOptionTransactionSupplement");
     
     if (dividendSwapOptionTransactionSupplementNode != null)
     {
         if (dividendSwapOptionTransactionSupplementNode.Attributes["href"] != null || dividendSwapOptionTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (dividendSwapOptionTransactionSupplementNode.Attributes["id"] != null) 
             {
                 dividendSwapOptionTransactionSupplementIDRef_ = dividendSwapOptionTransactionSupplementNode.Attributes["id"].Value;
                 DividendSwapOptionTransactionSupplement ob = new DividendSwapOptionTransactionSupplement(dividendSwapOptionTransactionSupplementNode);
                 IDManager.SetID(dividendSwapOptionTransactionSupplementIDRef_, ob);
             }
             else if (dividendSwapOptionTransactionSupplementNode.Attributes["href"] != null)
             {
                 dividendSwapOptionTransactionSupplementIDRef_ = dividendSwapOptionTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 dividendSwapOptionTransactionSupplement_ = new DividendSwapOptionTransactionSupplement(dividendSwapOptionTransactionSupplementNode);
             }
         }
         else
         {
             dividendSwapOptionTransactionSupplement_ = new DividendSwapOptionTransactionSupplement(dividendSwapOptionTransactionSupplementNode);
         }
     }
     
 
     XmlNode dividendSwapTransactionSupplementNode = xmlNode.SelectSingleNode("dividendSwapTransactionSupplement");
     
     if (dividendSwapTransactionSupplementNode != null)
     {
         if (dividendSwapTransactionSupplementNode.Attributes["href"] != null || dividendSwapTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (dividendSwapTransactionSupplementNode.Attributes["id"] != null) 
             {
                 dividendSwapTransactionSupplementIDRef_ = dividendSwapTransactionSupplementNode.Attributes["id"].Value;
                 DividendSwapTransactionSupplement ob = new DividendSwapTransactionSupplement(dividendSwapTransactionSupplementNode);
                 IDManager.SetID(dividendSwapTransactionSupplementIDRef_, ob);
             }
             else if (dividendSwapTransactionSupplementNode.Attributes["href"] != null)
             {
                 dividendSwapTransactionSupplementIDRef_ = dividendSwapTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 dividendSwapTransactionSupplement_ = new DividendSwapTransactionSupplement(dividendSwapTransactionSupplementNode);
             }
         }
         else
         {
             dividendSwapTransactionSupplement_ = new DividendSwapTransactionSupplement(dividendSwapTransactionSupplementNode);
         }
     }
     
 
     XmlNode instrumentTradeDetailsNode = xmlNode.SelectSingleNode("instrumentTradeDetails");
     
     if (instrumentTradeDetailsNode != null)
     {
         if (instrumentTradeDetailsNode.Attributes["href"] != null || instrumentTradeDetailsNode.Attributes["id"] != null) 
         {
             if (instrumentTradeDetailsNode.Attributes["id"] != null) 
             {
                 instrumentTradeDetailsIDRef_ = instrumentTradeDetailsNode.Attributes["id"].Value;
                 InstrumentTradeDetails ob = new InstrumentTradeDetails(instrumentTradeDetailsNode);
                 IDManager.SetID(instrumentTradeDetailsIDRef_, ob);
             }
             else if (instrumentTradeDetailsNode.Attributes["href"] != null)
             {
                 instrumentTradeDetailsIDRef_ = instrumentTradeDetailsNode.Attributes["href"].Value;
             }
             else
             {
                 instrumentTradeDetails_ = new InstrumentTradeDetails(instrumentTradeDetailsNode);
             }
         }
         else
         {
             instrumentTradeDetails_ = new InstrumentTradeDetails(instrumentTradeDetailsNode);
         }
     }
     
 
     XmlNode strategyNode = xmlNode.SelectSingleNode("strategy");
     
     if (strategyNode != null)
     {
         if (strategyNode.Attributes["href"] != null || strategyNode.Attributes["id"] != null) 
         {
             if (strategyNode.Attributes["id"] != null) 
             {
                 strategyIDRef_ = strategyNode.Attributes["id"].Value;
                 Strategy ob = new Strategy(strategyNode);
                 IDManager.SetID(strategyIDRef_, ob);
             }
             else if (strategyNode.Attributes["href"] != null)
             {
                 strategyIDRef_ = strategyNode.Attributes["href"].Value;
             }
             else
             {
                 strategy_ = new Strategy(strategyNode);
             }
         }
         else
         {
             strategy_ = new Strategy(strategyNode);
         }
     }
     
 
     XmlNode returnSwapNode = xmlNode.SelectSingleNode("returnSwap");
     
     if (returnSwapNode != null)
     {
         if (returnSwapNode.Attributes["href"] != null || returnSwapNode.Attributes["id"] != null) 
         {
             if (returnSwapNode.Attributes["id"] != null) 
             {
                 returnSwapIDRef_ = returnSwapNode.Attributes["id"].Value;
                 ReturnSwap ob = new ReturnSwap(returnSwapNode);
                 IDManager.SetID(returnSwapIDRef_, ob);
             }
             else if (returnSwapNode.Attributes["href"] != null)
             {
                 returnSwapIDRef_ = returnSwapNode.Attributes["href"].Value;
             }
             else
             {
                 returnSwap_ = new ReturnSwap(returnSwapNode);
             }
         }
         else
         {
             returnSwap_ = new ReturnSwap(returnSwapNode);
         }
     }
     
 
     XmlNode brokerEquityOptionNode = xmlNode.SelectSingleNode("brokerEquityOption");
     
     if (brokerEquityOptionNode != null)
     {
         if (brokerEquityOptionNode.Attributes["href"] != null || brokerEquityOptionNode.Attributes["id"] != null) 
         {
             if (brokerEquityOptionNode.Attributes["id"] != null) 
             {
                 brokerEquityOptionIDRef_ = brokerEquityOptionNode.Attributes["id"].Value;
                 BrokerEquityOption ob = new BrokerEquityOption(brokerEquityOptionNode);
                 IDManager.SetID(brokerEquityOptionIDRef_, ob);
             }
             else if (brokerEquityOptionNode.Attributes["href"] != null)
             {
                 brokerEquityOptionIDRef_ = brokerEquityOptionNode.Attributes["href"].Value;
             }
             else
             {
                 brokerEquityOption_ = new BrokerEquityOption(brokerEquityOptionNode);
             }
         }
         else
         {
             brokerEquityOption_ = new BrokerEquityOption(brokerEquityOptionNode);
         }
     }
     
 
     XmlNode equityForwardNode = xmlNode.SelectSingleNode("equityForward");
     
     if (equityForwardNode != null)
     {
         if (equityForwardNode.Attributes["href"] != null || equityForwardNode.Attributes["id"] != null) 
         {
             if (equityForwardNode.Attributes["id"] != null) 
             {
                 equityForwardIDRef_ = equityForwardNode.Attributes["id"].Value;
                 EquityForward ob = new EquityForward(equityForwardNode);
                 IDManager.SetID(equityForwardIDRef_, ob);
             }
             else if (equityForwardNode.Attributes["href"] != null)
             {
                 equityForwardIDRef_ = equityForwardNode.Attributes["href"].Value;
             }
             else
             {
                 equityForward_ = new EquityForward(equityForwardNode);
             }
         }
         else
         {
             equityForward_ = new EquityForward(equityForwardNode);
         }
     }
     
 
     XmlNode equityOptionNode = xmlNode.SelectSingleNode("equityOption");
     
     if (equityOptionNode != null)
     {
         if (equityOptionNode.Attributes["href"] != null || equityOptionNode.Attributes["id"] != null) 
         {
             if (equityOptionNode.Attributes["id"] != null) 
             {
                 equityOptionIDRef_ = equityOptionNode.Attributes["id"].Value;
                 EquityOption ob = new EquityOption(equityOptionNode);
                 IDManager.SetID(equityOptionIDRef_, ob);
             }
             else if (equityOptionNode.Attributes["href"] != null)
             {
                 equityOptionIDRef_ = equityOptionNode.Attributes["href"].Value;
             }
             else
             {
                 equityOption_ = new EquityOption(equityOptionNode);
             }
         }
         else
         {
             equityOption_ = new EquityOption(equityOptionNode);
         }
     }
     
 
     XmlNode equityOptionTransactionSupplementNode = xmlNode.SelectSingleNode("equityOptionTransactionSupplement");
     
     if (equityOptionTransactionSupplementNode != null)
     {
         if (equityOptionTransactionSupplementNode.Attributes["href"] != null || equityOptionTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (equityOptionTransactionSupplementNode.Attributes["id"] != null) 
             {
                 equityOptionTransactionSupplementIDRef_ = equityOptionTransactionSupplementNode.Attributes["id"].Value;
                 EquityOptionTransactionSupplement ob = new EquityOptionTransactionSupplement(equityOptionTransactionSupplementNode);
                 IDManager.SetID(equityOptionTransactionSupplementIDRef_, ob);
             }
             else if (equityOptionTransactionSupplementNode.Attributes["href"] != null)
             {
                 equityOptionTransactionSupplementIDRef_ = equityOptionTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 equityOptionTransactionSupplement_ = new EquityOptionTransactionSupplement(equityOptionTransactionSupplementNode);
             }
         }
         else
         {
             equityOptionTransactionSupplement_ = new EquityOptionTransactionSupplement(equityOptionTransactionSupplementNode);
         }
     }
     
 
     XmlNode fxSingleLegNode = xmlNode.SelectSingleNode("fxSingleLeg");
     
     if (fxSingleLegNode != null)
     {
         if (fxSingleLegNode.Attributes["href"] != null || fxSingleLegNode.Attributes["id"] != null) 
         {
             if (fxSingleLegNode.Attributes["id"] != null) 
             {
                 fxSingleLegIDRef_ = fxSingleLegNode.Attributes["id"].Value;
                 FxSingleLeg ob = new FxSingleLeg(fxSingleLegNode);
                 IDManager.SetID(fxSingleLegIDRef_, ob);
             }
             else if (fxSingleLegNode.Attributes["href"] != null)
             {
                 fxSingleLegIDRef_ = fxSingleLegNode.Attributes["href"].Value;
             }
             else
             {
                 fxSingleLeg_ = new FxSingleLeg(fxSingleLegNode);
             }
         }
         else
         {
             fxSingleLeg_ = new FxSingleLeg(fxSingleLegNode);
         }
     }
     
 
     XmlNode fxSwapNode = xmlNode.SelectSingleNode("fxSwap");
     
     if (fxSwapNode != null)
     {
         if (fxSwapNode.Attributes["href"] != null || fxSwapNode.Attributes["id"] != null) 
         {
             if (fxSwapNode.Attributes["id"] != null) 
             {
                 fxSwapIDRef_ = fxSwapNode.Attributes["id"].Value;
                 FxSwap ob = new FxSwap(fxSwapNode);
                 IDManager.SetID(fxSwapIDRef_, ob);
             }
             else if (fxSwapNode.Attributes["href"] != null)
             {
                 fxSwapIDRef_ = fxSwapNode.Attributes["href"].Value;
             }
             else
             {
                 fxSwap_ = new FxSwap(fxSwapNode);
             }
         }
         else
         {
             fxSwap_ = new FxSwap(fxSwapNode);
         }
     }
     
 
     XmlNode fxOptionNode = xmlNode.SelectSingleNode("fxOption");
     
     if (fxOptionNode != null)
     {
         if (fxOptionNode.Attributes["href"] != null || fxOptionNode.Attributes["id"] != null) 
         {
             if (fxOptionNode.Attributes["id"] != null) 
             {
                 fxOptionIDRef_ = fxOptionNode.Attributes["id"].Value;
                 FxOption ob = new FxOption(fxOptionNode);
                 IDManager.SetID(fxOptionIDRef_, ob);
             }
             else if (fxOptionNode.Attributes["href"] != null)
             {
                 fxOptionIDRef_ = fxOptionNode.Attributes["href"].Value;
             }
             else
             {
                 fxOption_ = new FxOption(fxOptionNode);
             }
         }
         else
         {
             fxOption_ = new FxOption(fxOptionNode);
         }
     }
     
 
     XmlNode fxDigitalOptionNode = xmlNode.SelectSingleNode("fxDigitalOption");
     
     if (fxDigitalOptionNode != null)
     {
         if (fxDigitalOptionNode.Attributes["href"] != null || fxDigitalOptionNode.Attributes["id"] != null) 
         {
             if (fxDigitalOptionNode.Attributes["id"] != null) 
             {
                 fxDigitalOptionIDRef_ = fxDigitalOptionNode.Attributes["id"].Value;
                 FxDigitalOption ob = new FxDigitalOption(fxDigitalOptionNode);
                 IDManager.SetID(fxDigitalOptionIDRef_, ob);
             }
             else if (fxDigitalOptionNode.Attributes["href"] != null)
             {
                 fxDigitalOptionIDRef_ = fxDigitalOptionNode.Attributes["href"].Value;
             }
             else
             {
                 fxDigitalOption_ = new FxDigitalOption(fxDigitalOptionNode);
             }
         }
         else
         {
             fxDigitalOption_ = new FxDigitalOption(fxDigitalOptionNode);
         }
     }
     
 
     XmlNode termDepositNode = xmlNode.SelectSingleNode("termDeposit");
     
     if (termDepositNode != null)
     {
         if (termDepositNode.Attributes["href"] != null || termDepositNode.Attributes["id"] != null) 
         {
             if (termDepositNode.Attributes["id"] != null) 
             {
                 termDepositIDRef_ = termDepositNode.Attributes["id"].Value;
                 TermDeposit ob = new TermDeposit(termDepositNode);
                 IDManager.SetID(termDepositIDRef_, ob);
             }
             else if (termDepositNode.Attributes["href"] != null)
             {
                 termDepositIDRef_ = termDepositNode.Attributes["href"].Value;
             }
             else
             {
                 termDeposit_ = new TermDeposit(termDepositNode);
             }
         }
         else
         {
             termDeposit_ = new TermDeposit(termDepositNode);
         }
     }
     
 
     XmlNode genericProductNode = xmlNode.SelectSingleNode("genericProduct");
     
     if (genericProductNode != null)
     {
         if (genericProductNode.Attributes["href"] != null || genericProductNode.Attributes["id"] != null) 
         {
             if (genericProductNode.Attributes["id"] != null) 
             {
                 genericProductIDRef_ = genericProductNode.Attributes["id"].Value;
                 GenericProduct ob = new GenericProduct(genericProductNode);
                 IDManager.SetID(genericProductIDRef_, ob);
             }
             else if (genericProductNode.Attributes["href"] != null)
             {
                 genericProductIDRef_ = genericProductNode.Attributes["href"].Value;
             }
             else
             {
                 genericProduct_ = new GenericProduct(genericProductNode);
             }
         }
         else
         {
             genericProduct_ = new GenericProduct(genericProductNode);
         }
     }
     
 
     XmlNode nonSchemaProductNode = xmlNode.SelectSingleNode("nonSchemaProduct");
     
     if (nonSchemaProductNode != null)
     {
         if (nonSchemaProductNode.Attributes["href"] != null || nonSchemaProductNode.Attributes["id"] != null) 
         {
             if (nonSchemaProductNode.Attributes["id"] != null) 
             {
                 nonSchemaProductIDRef_ = nonSchemaProductNode.Attributes["id"].Value;
                 GenericProduct ob = new GenericProduct(nonSchemaProductNode);
                 IDManager.SetID(nonSchemaProductIDRef_, ob);
             }
             else if (nonSchemaProductNode.Attributes["href"] != null)
             {
                 nonSchemaProductIDRef_ = nonSchemaProductNode.Attributes["href"].Value;
             }
             else
             {
                 nonSchemaProduct_ = new GenericProduct(nonSchemaProductNode);
             }
         }
         else
         {
             nonSchemaProduct_ = new GenericProduct(nonSchemaProductNode);
         }
     }
     
 
     XmlNode bulletPaymentNode = xmlNode.SelectSingleNode("bulletPayment");
     
     if (bulletPaymentNode != null)
     {
         if (bulletPaymentNode.Attributes["href"] != null || bulletPaymentNode.Attributes["id"] != null) 
         {
             if (bulletPaymentNode.Attributes["id"] != null) 
             {
                 bulletPaymentIDRef_ = bulletPaymentNode.Attributes["id"].Value;
                 BulletPayment ob = new BulletPayment(bulletPaymentNode);
                 IDManager.SetID(bulletPaymentIDRef_, ob);
             }
             else if (bulletPaymentNode.Attributes["href"] != null)
             {
                 bulletPaymentIDRef_ = bulletPaymentNode.Attributes["href"].Value;
             }
             else
             {
                 bulletPayment_ = new BulletPayment(bulletPaymentNode);
             }
         }
         else
         {
             bulletPayment_ = new BulletPayment(bulletPaymentNode);
         }
     }
     
 
     XmlNode capFloorNode = xmlNode.SelectSingleNode("capFloor");
     
     if (capFloorNode != null)
     {
         if (capFloorNode.Attributes["href"] != null || capFloorNode.Attributes["id"] != null) 
         {
             if (capFloorNode.Attributes["id"] != null) 
             {
                 capFloorIDRef_ = capFloorNode.Attributes["id"].Value;
                 CapFloor ob = new CapFloor(capFloorNode);
                 IDManager.SetID(capFloorIDRef_, ob);
             }
             else if (capFloorNode.Attributes["href"] != null)
             {
                 capFloorIDRef_ = capFloorNode.Attributes["href"].Value;
             }
             else
             {
                 capFloor_ = new CapFloor(capFloorNode);
             }
         }
         else
         {
             capFloor_ = new CapFloor(capFloorNode);
         }
     }
     
 
     XmlNode fraNode = xmlNode.SelectSingleNode("fra");
     
     if (fraNode != null)
     {
         if (fraNode.Attributes["href"] != null || fraNode.Attributes["id"] != null) 
         {
             if (fraNode.Attributes["id"] != null) 
             {
                 fraIDRef_ = fraNode.Attributes["id"].Value;
                 Fra ob = new Fra(fraNode);
                 IDManager.SetID(fraIDRef_, ob);
             }
             else if (fraNode.Attributes["href"] != null)
             {
                 fraIDRef_ = fraNode.Attributes["href"].Value;
             }
             else
             {
                 fra_ = new Fra(fraNode);
             }
         }
         else
         {
             fra_ = new Fra(fraNode);
         }
     }
     
 
     XmlNode swapNode = xmlNode.SelectSingleNode("swap");
     
     if (swapNode != null)
     {
         if (swapNode.Attributes["href"] != null || swapNode.Attributes["id"] != null) 
         {
             if (swapNode.Attributes["id"] != null) 
             {
                 swapIDRef_ = swapNode.Attributes["id"].Value;
                 Swap ob = new Swap(swapNode);
                 IDManager.SetID(swapIDRef_, ob);
             }
             else if (swapNode.Attributes["href"] != null)
             {
                 swapIDRef_ = swapNode.Attributes["href"].Value;
             }
             else
             {
                 swap_ = new Swap(swapNode);
             }
         }
         else
         {
             swap_ = new Swap(swapNode);
         }
     }
     
 
     XmlNode swaptionNode = xmlNode.SelectSingleNode("swaption");
     
     if (swaptionNode != null)
     {
         if (swaptionNode.Attributes["href"] != null || swaptionNode.Attributes["id"] != null) 
         {
             if (swaptionNode.Attributes["id"] != null) 
             {
                 swaptionIDRef_ = swaptionNode.Attributes["id"].Value;
                 Swaption ob = new Swaption(swaptionNode);
                 IDManager.SetID(swaptionIDRef_, ob);
             }
             else if (swaptionNode.Attributes["href"] != null)
             {
                 swaptionIDRef_ = swaptionNode.Attributes["href"].Value;
             }
             else
             {
                 swaption_ = new Swaption(swaptionNode);
             }
         }
         else
         {
             swaption_ = new Swaption(swaptionNode);
         }
     }
     
 
     XmlNode equitySwapTransactionSupplementNode = xmlNode.SelectSingleNode("equitySwapTransactionSupplement");
     
     if (equitySwapTransactionSupplementNode != null)
     {
         if (equitySwapTransactionSupplementNode.Attributes["href"] != null || equitySwapTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (equitySwapTransactionSupplementNode.Attributes["id"] != null) 
             {
                 equitySwapTransactionSupplementIDRef_ = equitySwapTransactionSupplementNode.Attributes["id"].Value;
                 EquitySwapTransactionSupplement ob = new EquitySwapTransactionSupplement(equitySwapTransactionSupplementNode);
                 IDManager.SetID(equitySwapTransactionSupplementIDRef_, ob);
             }
             else if (equitySwapTransactionSupplementNode.Attributes["href"] != null)
             {
                 equitySwapTransactionSupplementIDRef_ = equitySwapTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 equitySwapTransactionSupplement_ = new EquitySwapTransactionSupplement(equitySwapTransactionSupplementNode);
             }
         }
         else
         {
             equitySwapTransactionSupplement_ = new EquitySwapTransactionSupplement(equitySwapTransactionSupplementNode);
         }
     }
     
 
     XmlNode standardProductNode = xmlNode.SelectSingleNode("standardProduct");
     
     if (standardProductNode != null)
     {
         if (standardProductNode.Attributes["href"] != null || standardProductNode.Attributes["id"] != null) 
         {
             if (standardProductNode.Attributes["id"] != null) 
             {
                 standardProductIDRef_ = standardProductNode.Attributes["id"].Value;
                 StandardProduct ob = new StandardProduct(standardProductNode);
                 IDManager.SetID(standardProductIDRef_, ob);
             }
             else if (standardProductNode.Attributes["href"] != null)
             {
                 standardProductIDRef_ = standardProductNode.Attributes["href"].Value;
             }
             else
             {
                 standardProduct_ = new StandardProduct(standardProductNode);
             }
         }
         else
         {
             standardProduct_ = new StandardProduct(standardProductNode);
         }
     }
     
 
     XmlNode varianceOptionTransactionSupplementNode = xmlNode.SelectSingleNode("varianceOptionTransactionSupplement");
     
     if (varianceOptionTransactionSupplementNode != null)
     {
         if (varianceOptionTransactionSupplementNode.Attributes["href"] != null || varianceOptionTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (varianceOptionTransactionSupplementNode.Attributes["id"] != null) 
             {
                 varianceOptionTransactionSupplementIDRef_ = varianceOptionTransactionSupplementNode.Attributes["id"].Value;
                 VarianceOptionTransactionSupplement ob = new VarianceOptionTransactionSupplement(varianceOptionTransactionSupplementNode);
                 IDManager.SetID(varianceOptionTransactionSupplementIDRef_, ob);
             }
             else if (varianceOptionTransactionSupplementNode.Attributes["href"] != null)
             {
                 varianceOptionTransactionSupplementIDRef_ = varianceOptionTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 varianceOptionTransactionSupplement_ = new VarianceOptionTransactionSupplement(varianceOptionTransactionSupplementNode);
             }
         }
         else
         {
             varianceOptionTransactionSupplement_ = new VarianceOptionTransactionSupplement(varianceOptionTransactionSupplementNode);
         }
     }
     
 
     XmlNode varianceSwapNode = xmlNode.SelectSingleNode("varianceSwap");
     
     if (varianceSwapNode != null)
     {
         if (varianceSwapNode.Attributes["href"] != null || varianceSwapNode.Attributes["id"] != null) 
         {
             if (varianceSwapNode.Attributes["id"] != null) 
             {
                 varianceSwapIDRef_ = varianceSwapNode.Attributes["id"].Value;
                 VarianceSwap ob = new VarianceSwap(varianceSwapNode);
                 IDManager.SetID(varianceSwapIDRef_, ob);
             }
             else if (varianceSwapNode.Attributes["href"] != null)
             {
                 varianceSwapIDRef_ = varianceSwapNode.Attributes["href"].Value;
             }
             else
             {
                 varianceSwap_ = new VarianceSwap(varianceSwapNode);
             }
         }
         else
         {
             varianceSwap_ = new VarianceSwap(varianceSwapNode);
         }
     }
     
 
     XmlNode varianceSwapTransactionSupplementNode = xmlNode.SelectSingleNode("varianceSwapTransactionSupplement");
     
     if (varianceSwapTransactionSupplementNode != null)
     {
         if (varianceSwapTransactionSupplementNode.Attributes["href"] != null || varianceSwapTransactionSupplementNode.Attributes["id"] != null) 
         {
             if (varianceSwapTransactionSupplementNode.Attributes["id"] != null) 
             {
                 varianceSwapTransactionSupplementIDRef_ = varianceSwapTransactionSupplementNode.Attributes["id"].Value;
                 VarianceSwapTransactionSupplement ob = new VarianceSwapTransactionSupplement(varianceSwapTransactionSupplementNode);
                 IDManager.SetID(varianceSwapTransactionSupplementIDRef_, ob);
             }
             else if (varianceSwapTransactionSupplementNode.Attributes["href"] != null)
             {
                 varianceSwapTransactionSupplementIDRef_ = varianceSwapTransactionSupplementNode.Attributes["href"].Value;
             }
             else
             {
                 varianceSwapTransactionSupplement_ = new VarianceSwapTransactionSupplement(varianceSwapTransactionSupplementNode);
             }
         }
         else
         {
             varianceSwapTransactionSupplement_ = new VarianceSwapTransactionSupplement(varianceSwapTransactionSupplementNode);
         }
     }
     
 
     XmlNodeList otherPartyPaymentNodeList = xmlNode.SelectNodes("otherPartyPayment");
     
     if (otherPartyPaymentNodeList != null)
     {
         this.otherPartyPayment_ = new List<Payment>();
         foreach (XmlNode item in otherPartyPaymentNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     otherPartyPaymentIDRef_ = item.Attributes["id"].Value;
                     otherPartyPayment_.Add(new Payment(item));
                     IDManager.SetID(otherPartyPaymentIDRef_, otherPartyPayment_[otherPartyPayment_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     otherPartyPaymentIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 otherPartyPayment_.Add(new Payment(item));
                 }
             }
             else
             {
                 otherPartyPayment_.Add(new Payment(item));
             }
         }
     }
     
 
     XmlNodeList brokerPartyReferenceNodeList = xmlNode.SelectNodes("brokerPartyReference");
     
     if (brokerPartyReferenceNodeList != null)
     {
         this.brokerPartyReference_ = new List<PartyReference>();
         foreach (XmlNode item in brokerPartyReferenceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     brokerPartyReferenceIDRef_ = item.Attributes["id"].Value;
                     brokerPartyReference_.Add(new PartyReference(item));
                     IDManager.SetID(brokerPartyReferenceIDRef_, brokerPartyReference_[brokerPartyReference_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     brokerPartyReferenceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 brokerPartyReference_.Add(new PartyReference(item));
                 }
             }
             else
             {
                 brokerPartyReference_.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");
     
     if (calculationAgentNode != null)
     {
         if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null) 
         {
             if (calculationAgentNode.Attributes["id"] != null) 
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                 CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                 IDManager.SetID(calculationAgentIDRef_, ob);
             }
             else if (calculationAgentNode.Attributes["href"] != null)
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgent_ = new CalculationAgent(calculationAgentNode);
             }
         }
         else
         {
             calculationAgent_ = new CalculationAgent(calculationAgentNode);
         }
     }
     
 
     XmlNode calculationAgentBusinessCenterNode = xmlNode.SelectSingleNode("calculationAgentBusinessCenter");
     
     if (calculationAgentBusinessCenterNode != null)
     {
         if (calculationAgentBusinessCenterNode.Attributes["href"] != null || calculationAgentBusinessCenterNode.Attributes["id"] != null) 
         {
             if (calculationAgentBusinessCenterNode.Attributes["id"] != null) 
             {
                 calculationAgentBusinessCenterIDRef_ = calculationAgentBusinessCenterNode.Attributes["id"].Value;
                 BusinessCenter ob = new BusinessCenter(calculationAgentBusinessCenterNode);
                 IDManager.SetID(calculationAgentBusinessCenterIDRef_, ob);
             }
             else if (calculationAgentBusinessCenterNode.Attributes["href"] != null)
             {
                 calculationAgentBusinessCenterIDRef_ = calculationAgentBusinessCenterNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgentBusinessCenter_ = new BusinessCenter(calculationAgentBusinessCenterNode);
             }
         }
         else
         {
             calculationAgentBusinessCenter_ = new BusinessCenter(calculationAgentBusinessCenterNode);
         }
     }
     
 
     XmlNodeList determiningPartyNodeList = xmlNode.SelectNodes("determiningParty");
     
     if (determiningPartyNodeList != null)
     {
         this.determiningParty_ = new List<PartyReference>();
         foreach (XmlNode item in determiningPartyNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     determiningPartyIDRef_ = item.Attributes["id"].Value;
                     determiningParty_.Add(new PartyReference(item));
                     IDManager.SetID(determiningPartyIDRef_, determiningParty_[determiningParty_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     determiningPartyIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 determiningParty_.Add(new PartyReference(item));
                 }
             }
             else
             {
                 determiningParty_.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNodeList hedgingPartyNodeList = xmlNode.SelectNodes("hedgingParty");
     
     if (hedgingPartyNodeList != null)
     {
         this.hedgingParty_ = new List<PartyReference>();
         foreach (XmlNode item in hedgingPartyNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     hedgingPartyIDRef_ = item.Attributes["id"].Value;
                     hedgingParty_.Add(new PartyReference(item));
                     IDManager.SetID(hedgingPartyIDRef_, hedgingParty_[hedgingParty_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     hedgingPartyIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 hedgingParty_.Add(new PartyReference(item));
                 }
             }
             else
             {
                 hedgingParty_.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNode collateralNode = xmlNode.SelectSingleNode("collateral");
     
     if (collateralNode != null)
     {
         if (collateralNode.Attributes["href"] != null || collateralNode.Attributes["id"] != null) 
         {
             if (collateralNode.Attributes["id"] != null) 
             {
                 collateralIDRef_ = collateralNode.Attributes["id"].Value;
                 Collateral ob = new Collateral(collateralNode);
                 IDManager.SetID(collateralIDRef_, ob);
             }
             else if (collateralNode.Attributes["href"] != null)
             {
                 collateralIDRef_ = collateralNode.Attributes["href"].Value;
             }
             else
             {
                 collateral_ = new Collateral(collateralNode);
             }
         }
         else
         {
             collateral_ = new Collateral(collateralNode);
         }
     }
     
 
     XmlNode documentationNode = xmlNode.SelectSingleNode("documentation");
     
     if (documentationNode != null)
     {
         if (documentationNode.Attributes["href"] != null || documentationNode.Attributes["id"] != null) 
         {
             if (documentationNode.Attributes["id"] != null) 
             {
                 documentationIDRef_ = documentationNode.Attributes["id"].Value;
                 Documentation ob = new Documentation(documentationNode);
                 IDManager.SetID(documentationIDRef_, ob);
             }
             else if (documentationNode.Attributes["href"] != null)
             {
                 documentationIDRef_ = documentationNode.Attributes["href"].Value;
             }
             else
             {
                 documentation_ = new Documentation(documentationNode);
             }
         }
         else
         {
             documentation_ = new Documentation(documentationNode);
         }
     }
     
 
     XmlNode governingLawNode = xmlNode.SelectSingleNode("governingLaw");
     
     if (governingLawNode != null)
     {
         if (governingLawNode.Attributes["href"] != null || governingLawNode.Attributes["id"] != null) 
         {
             if (governingLawNode.Attributes["id"] != null) 
             {
                 governingLawIDRef_ = governingLawNode.Attributes["id"].Value;
                 GoverningLaw ob = new GoverningLaw(governingLawNode);
                 IDManager.SetID(governingLawIDRef_, ob);
             }
             else if (governingLawNode.Attributes["href"] != null)
             {
                 governingLawIDRef_ = governingLawNode.Attributes["href"].Value;
             }
             else
             {
                 governingLaw_ = new GoverningLaw(governingLawNode);
             }
         }
         else
         {
             governingLaw_ = new GoverningLaw(governingLawNode);
         }
     }
     
 
     XmlNode allocationsNode = xmlNode.SelectSingleNode("allocations");
     
     if (allocationsNode != null)
     {
         if (allocationsNode.Attributes["href"] != null || allocationsNode.Attributes["id"] != null) 
         {
             if (allocationsNode.Attributes["id"] != null) 
             {
                 allocationsIDRef_ = allocationsNode.Attributes["id"].Value;
                 Allocations ob = new Allocations(allocationsNode);
                 IDManager.SetID(allocationsIDRef_, ob);
             }
             else if (allocationsNode.Attributes["href"] != null)
             {
                 allocationsIDRef_ = allocationsNode.Attributes["href"].Value;
             }
             else
             {
                 allocations_ = new Allocations(allocationsNode);
             }
         }
         else
         {
             allocations_ = new Allocations(allocationsNode);
         }
     }
     
 
 }
Example #2
0
        public FallbackReferencePrice(XmlNode xmlNode)
        {
            XmlNodeList valuationPostponementNodeList = xmlNode.SelectNodes("valuationPostponement");

            if (valuationPostponementNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in valuationPostponementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationPostponementIDRef = item.Attributes["id"].Name;
                        ValuationPostponement ob = ValuationPostponement();
                        IDManager.SetID(valuationPostponementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationPostponementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationPostponement = new ValuationPostponement(item);
                    }
                }
            }


            XmlNodeList fallbackSettlementRateOptionNodeList = xmlNode.SelectNodes("fallbackSettlementRateOption");

            foreach (XmlNode item in fallbackSettlementRateOptionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fallbackSettlementRateOptionIDRef = item.Attributes["id"].Name;
                        List <SettlementRateOption> ob = new List <SettlementRateOption>();
                        ob.Add(new SettlementRateOption(item));
                        IDManager.SetID(fallbackSettlementRateOptionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fallbackSettlementRateOptionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fallbackSettlementRateOption.Add(new SettlementRateOption(item));
                    }
                }
            }


            XmlNodeList fallbackSurveyValuationPostponenmentNodeList = xmlNode.SelectNodes("fallbackSurveyValuationPostponenment");

            if (fallbackSurveyValuationPostponenmentNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in fallbackSurveyValuationPostponenmentNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fallbackSurveyValuationPostponenmentIDRef = item.Attributes["id"].Name;
                        Empty ob = Empty();
                        IDManager.SetID(fallbackSurveyValuationPostponenmentIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fallbackSurveyValuationPostponenmentIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fallbackSurveyValuationPostponenment = new Empty(item);
                    }
                }
            }


            XmlNodeList calculationAgentDeterminationNodeList = xmlNode.SelectNodes("calculationAgentDetermination");

            if (calculationAgentDeterminationNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in calculationAgentDeterminationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        calculationAgentDeterminationIDRef = item.Attributes["id"].Name;
                        CalculationAgent ob = CalculationAgent();
                        IDManager.SetID(calculationAgentDeterminationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        calculationAgentDeterminationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        calculationAgentDetermination = new CalculationAgent(item);
                    }
                }
            }
        }
 public MandatoryEarlyTermination(XmlNode xmlNode)
 {
     XmlNodeList mandatoryEarlyTerminationDateNodeList = xmlNode.SelectNodes("mandatoryEarlyTerminationDate");
     if (mandatoryEarlyTerminationDateNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mandatoryEarlyTerminationDateNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mandatoryEarlyTerminationDateIDRef = item.Attributes["id"].Name;
                 AdjustableDate ob = AdjustableDate();
                 IDManager.SetID(mandatoryEarlyTerminationDateIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mandatoryEarlyTerminationDateIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mandatoryEarlyTerminationDate = new AdjustableDate(item);
             }
         }
     }
     
 
     XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");
     if (calculationAgentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentIDRef = item.Attributes["id"].Name;
                 CalculationAgent ob = CalculationAgent();
                 IDManager.SetID(calculationAgentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgent = new CalculationAgent(item);
             }
         }
     }
     
 
     XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");
     if (cashSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementIDRef = item.Attributes["id"].Name;
                 CashSettlement ob = CashSettlement();
                 IDManager.SetID(cashSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlement = new CashSettlement(item);
             }
         }
     }
     
 
     XmlNodeList mandatoryEarlyTerminationAdjustedDatesNodeList = xmlNode.SelectNodes("mandatoryEarlyTerminationAdjustedDates");
     if (mandatoryEarlyTerminationAdjustedDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in mandatoryEarlyTerminationAdjustedDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 mandatoryEarlyTerminationAdjustedDatesIDRef = item.Attributes["id"].Name;
                 MandatoryEarlyTerminationAdjustedDates ob = MandatoryEarlyTerminationAdjustedDates();
                 IDManager.SetID(mandatoryEarlyTerminationAdjustedDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 mandatoryEarlyTerminationAdjustedDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 mandatoryEarlyTerminationAdjustedDates = new MandatoryEarlyTerminationAdjustedDates(item);
             }
         }
     }
     
 
 }
 public Trade(XmlNode xmlNode)
 {
     XmlNodeList tradeHeaderNodeList = xmlNode.SelectNodes("tradeHeader");
     if (tradeHeaderNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeHeaderNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeHeaderIDRef = item.Attributes["id"].Name;
                 TradeHeader ob = TradeHeader();
                 IDManager.SetID(tradeHeaderIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeHeaderIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeHeader = new TradeHeader(item);
             }
         }
     }
     
 
     XmlNodeList productNodeList = xmlNode.SelectNodes("product");
     if (productNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in productNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 productIDRef = item.Attributes["id"].Name;
                 Product ob = Product();
                 IDManager.SetID(productIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 productIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 product = new Product(item);
             }
         }
     }
     
 
     XmlNodeList forwardNodeList = xmlNode.SelectNodes("forward");
     if (forwardNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in forwardNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 forwardIDRef = item.Attributes["id"].Name;
                 ForwardSale ob = ForwardSale();
                 IDManager.SetID(forwardIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 forwardIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 forward = new ForwardSale(item);
             }
         }
     }
     
 
     XmlNodeList bondOptionNodeList = xmlNode.SelectNodes("bondOption");
     if (bondOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bondOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bondOptionIDRef = item.Attributes["id"].Name;
                 BondOption ob = BondOption();
                 IDManager.SetID(bondOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bondOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bondOption = new BondOption(item);
             }
         }
     }
     
 
     XmlNodeList creditDefaultSwapNodeList = xmlNode.SelectNodes("creditDefaultSwap");
     if (creditDefaultSwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditDefaultSwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditDefaultSwapIDRef = item.Attributes["id"].Name;
                 CreditDefaultSwap ob = CreditDefaultSwap();
                 IDManager.SetID(creditDefaultSwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditDefaultSwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditDefaultSwap = new CreditDefaultSwap(item);
             }
         }
     }
     
 
     XmlNodeList creditDefaultSwapOptionNodeList = xmlNode.SelectNodes("creditDefaultSwapOption");
     if (creditDefaultSwapOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in creditDefaultSwapOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 creditDefaultSwapOptionIDRef = item.Attributes["id"].Name;
                 CreditDefaultSwapOption ob = CreditDefaultSwapOption();
                 IDManager.SetID(creditDefaultSwapOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 creditDefaultSwapOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 creditDefaultSwapOption = new CreditDefaultSwapOption(item);
             }
         }
     }
     
 
     XmlNodeList commodityForwardNodeList = xmlNode.SelectNodes("commodityForward");
     if (commodityForwardNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commodityForwardNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commodityForwardIDRef = item.Attributes["id"].Name;
                 CommodityForward ob = CommodityForward();
                 IDManager.SetID(commodityForwardIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commodityForwardIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 commodityForward = new CommodityForward(item);
             }
         }
     }
     
 
     XmlNodeList commodityOptionNodeList = xmlNode.SelectNodes("commodityOption");
     if (commodityOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commodityOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commodityOptionIDRef = item.Attributes["id"].Name;
                 CommodityOption ob = CommodityOption();
                 IDManager.SetID(commodityOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commodityOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 commodityOption = new CommodityOption(item);
             }
         }
     }
     
 
     XmlNodeList commoditySwapNodeList = xmlNode.SelectNodes("commoditySwap");
     if (commoditySwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commoditySwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commoditySwapIDRef = item.Attributes["id"].Name;
                 CommoditySwap ob = CommoditySwap();
                 IDManager.SetID(commoditySwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commoditySwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 commoditySwap = new CommoditySwap(item);
             }
         }
     }
     
 
     XmlNodeList commoditySwaptionNodeList = xmlNode.SelectNodes("commoditySwaption");
     if (commoditySwaptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in commoditySwaptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 commoditySwaptionIDRef = item.Attributes["id"].Name;
                 CommoditySwaption ob = CommoditySwaption();
                 IDManager.SetID(commoditySwaptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 commoditySwaptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 commoditySwaption = new CommoditySwaption(item);
             }
         }
     }
     
 
     XmlNodeList correlationSwapNodeList = xmlNode.SelectNodes("correlationSwap");
     if (correlationSwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationSwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationSwapIDRef = item.Attributes["id"].Name;
                 CorrelationSwap ob = CorrelationSwap();
                 IDManager.SetID(correlationSwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationSwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationSwap = new CorrelationSwap(item);
             }
         }
     }
     
 
     XmlNodeList dividendSwapOptionTransactionSupplementNodeList = xmlNode.SelectNodes("dividendSwapOptionTransactionSupplement");
     if (dividendSwapOptionTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendSwapOptionTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendSwapOptionTransactionSupplementIDRef = item.Attributes["id"].Name;
                 DividendSwapOptionTransactionSupplement ob = DividendSwapOptionTransactionSupplement();
                 IDManager.SetID(dividendSwapOptionTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendSwapOptionTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendSwapOptionTransactionSupplement = new DividendSwapOptionTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList dividendSwapTransactionSupplementNodeList = xmlNode.SelectNodes("dividendSwapTransactionSupplement");
     if (dividendSwapTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in dividendSwapTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 dividendSwapTransactionSupplementIDRef = item.Attributes["id"].Name;
                 DividendSwapTransactionSupplement ob = DividendSwapTransactionSupplement();
                 IDManager.SetID(dividendSwapTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 dividendSwapTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 dividendSwapTransactionSupplement = new DividendSwapTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList instrumentTradeDetailsNodeList = xmlNode.SelectNodes("instrumentTradeDetails");
     if (instrumentTradeDetailsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in instrumentTradeDetailsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 instrumentTradeDetailsIDRef = item.Attributes["id"].Name;
                 InstrumentTradeDetails ob = InstrumentTradeDetails();
                 IDManager.SetID(instrumentTradeDetailsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 instrumentTradeDetailsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 instrumentTradeDetails = new InstrumentTradeDetails(item);
             }
         }
     }
     
 
     XmlNodeList strategyNodeList = xmlNode.SelectNodes("strategy");
     if (strategyNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in strategyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 strategyIDRef = item.Attributes["id"].Name;
                 Strategy ob = Strategy();
                 IDManager.SetID(strategyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 strategyIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 strategy = new Strategy(item);
             }
         }
     }
     
 
     XmlNodeList returnSwapNodeList = xmlNode.SelectNodes("returnSwap");
     if (returnSwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in returnSwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 returnSwapIDRef = item.Attributes["id"].Name;
                 ReturnSwap ob = ReturnSwap();
                 IDManager.SetID(returnSwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 returnSwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 returnSwap = new ReturnSwap(item);
             }
         }
     }
     
 
     XmlNodeList brokerEquityOptionNodeList = xmlNode.SelectNodes("brokerEquityOption");
     if (brokerEquityOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in brokerEquityOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 brokerEquityOptionIDRef = item.Attributes["id"].Name;
                 BrokerEquityOption ob = BrokerEquityOption();
                 IDManager.SetID(brokerEquityOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 brokerEquityOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 brokerEquityOption = new BrokerEquityOption(item);
             }
         }
     }
     
 
     XmlNodeList equityForwardNodeList = xmlNode.SelectNodes("equityForward");
     if (equityForwardNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityForwardNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityForwardIDRef = item.Attributes["id"].Name;
                 EquityForward ob = EquityForward();
                 IDManager.SetID(equityForwardIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityForwardIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityForward = new EquityForward(item);
             }
         }
     }
     
 
     XmlNodeList equityOptionNodeList = xmlNode.SelectNodes("equityOption");
     if (equityOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityOptionIDRef = item.Attributes["id"].Name;
                 EquityOption ob = EquityOption();
                 IDManager.SetID(equityOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityOption = new EquityOption(item);
             }
         }
     }
     
 
     XmlNodeList equityOptionTransactionSupplementNodeList = xmlNode.SelectNodes("equityOptionTransactionSupplement");
     if (equityOptionTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equityOptionTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equityOptionTransactionSupplementIDRef = item.Attributes["id"].Name;
                 EquityOptionTransactionSupplement ob = EquityOptionTransactionSupplement();
                 IDManager.SetID(equityOptionTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equityOptionTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equityOptionTransactionSupplement = new EquityOptionTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList fxSingleLegNodeList = xmlNode.SelectNodes("fxSingleLeg");
     if (fxSingleLegNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxSingleLegNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxSingleLegIDRef = item.Attributes["id"].Name;
                 FxSingleLeg ob = FxSingleLeg();
                 IDManager.SetID(fxSingleLegIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxSingleLegIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxSingleLeg = new FxSingleLeg(item);
             }
         }
     }
     
 
     XmlNodeList fxSwapNodeList = xmlNode.SelectNodes("fxSwap");
     if (fxSwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxSwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxSwapIDRef = item.Attributes["id"].Name;
                 FxSwap ob = FxSwap();
                 IDManager.SetID(fxSwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxSwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxSwap = new FxSwap(item);
             }
         }
     }
     
 
     XmlNodeList fxOptionNodeList = xmlNode.SelectNodes("fxOption");
     if (fxOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxOptionIDRef = item.Attributes["id"].Name;
                 FxOption ob = FxOption();
                 IDManager.SetID(fxOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxOption = new FxOption(item);
             }
         }
     }
     
 
     XmlNodeList fxDigitalOptionNodeList = xmlNode.SelectNodes("fxDigitalOption");
     if (fxDigitalOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fxDigitalOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fxDigitalOptionIDRef = item.Attributes["id"].Name;
                 FxDigitalOption ob = FxDigitalOption();
                 IDManager.SetID(fxDigitalOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fxDigitalOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fxDigitalOption = new FxDigitalOption(item);
             }
         }
     }
     
 
     XmlNodeList termDepositNodeList = xmlNode.SelectNodes("termDeposit");
     if (termDepositNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in termDepositNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 termDepositIDRef = item.Attributes["id"].Name;
                 TermDeposit ob = TermDeposit();
                 IDManager.SetID(termDepositIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 termDepositIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 termDeposit = new TermDeposit(item);
             }
         }
     }
     
 
     XmlNodeList genericProductNodeList = xmlNode.SelectNodes("genericProduct");
     if (genericProductNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in genericProductNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 genericProductIDRef = item.Attributes["id"].Name;
                 GenericProduct ob = GenericProduct();
                 IDManager.SetID(genericProductIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 genericProductIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 genericProduct = new GenericProduct(item);
             }
         }
     }
     
 
     XmlNodeList nonSchemaProductNodeList = xmlNode.SelectNodes("nonSchemaProduct");
     if (nonSchemaProductNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in nonSchemaProductNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 nonSchemaProductIDRef = item.Attributes["id"].Name;
                 GenericProduct ob = GenericProduct();
                 IDManager.SetID(nonSchemaProductIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 nonSchemaProductIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 nonSchemaProduct = new GenericProduct(item);
             }
         }
     }
     
 
     XmlNodeList bulletPaymentNodeList = xmlNode.SelectNodes("bulletPayment");
     if (bulletPaymentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bulletPaymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bulletPaymentIDRef = item.Attributes["id"].Name;
                 BulletPayment ob = BulletPayment();
                 IDManager.SetID(bulletPaymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bulletPaymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bulletPayment = new BulletPayment(item);
             }
         }
     }
     
 
     XmlNodeList capFloorNodeList = xmlNode.SelectNodes("capFloor");
     if (capFloorNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in capFloorNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 capFloorIDRef = item.Attributes["id"].Name;
                 CapFloor ob = CapFloor();
                 IDManager.SetID(capFloorIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 capFloorIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 capFloor = new CapFloor(item);
             }
         }
     }
     
 
     XmlNodeList fraNodeList = xmlNode.SelectNodes("fra");
     if (fraNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fraNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fraIDRef = item.Attributes["id"].Name;
                 Fra ob = Fra();
                 IDManager.SetID(fraIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fraIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fra = new Fra(item);
             }
         }
     }
     
 
     XmlNodeList swapNodeList = xmlNode.SelectNodes("swap");
     if (swapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swapIDRef = item.Attributes["id"].Name;
                 Swap ob = Swap();
                 IDManager.SetID(swapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swap = new Swap(item);
             }
         }
     }
     
 
     XmlNodeList swaptionNodeList = xmlNode.SelectNodes("swaption");
     if (swaptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swaptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swaptionIDRef = item.Attributes["id"].Name;
                 Swaption ob = Swaption();
                 IDManager.SetID(swaptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swaptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swaption = new Swaption(item);
             }
         }
     }
     
 
     XmlNodeList equitySwapTransactionSupplementNodeList = xmlNode.SelectNodes("equitySwapTransactionSupplement");
     if (equitySwapTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in equitySwapTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 equitySwapTransactionSupplementIDRef = item.Attributes["id"].Name;
                 EquitySwapTransactionSupplement ob = EquitySwapTransactionSupplement();
                 IDManager.SetID(equitySwapTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 equitySwapTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 equitySwapTransactionSupplement = new EquitySwapTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList standardProductNodeList = xmlNode.SelectNodes("standardProduct");
     if (standardProductNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in standardProductNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 standardProductIDRef = item.Attributes["id"].Name;
                 StandardProduct ob = StandardProduct();
                 IDManager.SetID(standardProductIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 standardProductIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 standardProduct = new StandardProduct(item);
             }
         }
     }
     
 
     XmlNodeList varianceOptionTransactionSupplementNodeList = xmlNode.SelectNodes("varianceOptionTransactionSupplement");
     if (varianceOptionTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceOptionTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceOptionTransactionSupplementIDRef = item.Attributes["id"].Name;
                 VarianceOptionTransactionSupplement ob = VarianceOptionTransactionSupplement();
                 IDManager.SetID(varianceOptionTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceOptionTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceOptionTransactionSupplement = new VarianceOptionTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList varianceSwapNodeList = xmlNode.SelectNodes("varianceSwap");
     if (varianceSwapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceSwapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceSwapIDRef = item.Attributes["id"].Name;
                 VarianceSwap ob = VarianceSwap();
                 IDManager.SetID(varianceSwapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceSwapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceSwap = new VarianceSwap(item);
             }
         }
     }
     
 
     XmlNodeList varianceSwapTransactionSupplementNodeList = xmlNode.SelectNodes("varianceSwapTransactionSupplement");
     if (varianceSwapTransactionSupplementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in varianceSwapTransactionSupplementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 varianceSwapTransactionSupplementIDRef = item.Attributes["id"].Name;
                 VarianceSwapTransactionSupplement ob = VarianceSwapTransactionSupplement();
                 IDManager.SetID(varianceSwapTransactionSupplementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 varianceSwapTransactionSupplementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 varianceSwapTransactionSupplement = new VarianceSwapTransactionSupplement(item);
             }
         }
     }
     
 
     XmlNodeList otherPartyPaymentNodeList = xmlNode.SelectNodes("otherPartyPayment");
     
     foreach (XmlNode item in otherPartyPaymentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 otherPartyPaymentIDRef = item.Attributes["id"].Name;
                 List<Payment> ob = new List<Payment>();
                 ob.Add(new Payment(item));
                 IDManager.SetID(otherPartyPaymentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 otherPartyPaymentIDRef = item.Attributes["href"].Name;
             }
             else
             {
             otherPartyPayment.Add(new Payment(item));
             }
         }
     }
     
 
     XmlNodeList brokerPartyReferenceNodeList = xmlNode.SelectNodes("brokerPartyReference");
     
     foreach (XmlNode item in brokerPartyReferenceNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 brokerPartyReferenceIDRef = item.Attributes["id"].Name;
                 List<PartyReference> ob = new List<PartyReference>();
                 ob.Add(new PartyReference(item));
                 IDManager.SetID(brokerPartyReferenceIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 brokerPartyReferenceIDRef = item.Attributes["href"].Name;
             }
             else
             {
             brokerPartyReference.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");
     if (calculationAgentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentIDRef = item.Attributes["id"].Name;
                 CalculationAgent ob = CalculationAgent();
                 IDManager.SetID(calculationAgentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgent = new CalculationAgent(item);
             }
         }
     }
     
 
     XmlNodeList calculationAgentBusinessCenterNodeList = xmlNode.SelectNodes("calculationAgentBusinessCenter");
     if (calculationAgentBusinessCenterNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentBusinessCenterNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentBusinessCenterIDRef = item.Attributes["id"].Name;
                 BusinessCenter ob = BusinessCenter();
                 IDManager.SetID(calculationAgentBusinessCenterIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentBusinessCenterIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgentBusinessCenter = new BusinessCenter(item);
             }
         }
     }
     
 
     XmlNodeList determiningPartyNodeList = xmlNode.SelectNodes("determiningParty");
     
     foreach (XmlNode item in determiningPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 determiningPartyIDRef = item.Attributes["id"].Name;
                 List<PartyReference> ob = new List<PartyReference>();
                 ob.Add(new PartyReference(item));
                 IDManager.SetID(determiningPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 determiningPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
             determiningParty.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNodeList hedgingPartyNodeList = xmlNode.SelectNodes("hedgingParty");
     
     foreach (XmlNode item in hedgingPartyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 hedgingPartyIDRef = item.Attributes["id"].Name;
                 List<PartyReference> ob = new List<PartyReference>();
                 ob.Add(new PartyReference(item));
                 IDManager.SetID(hedgingPartyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 hedgingPartyIDRef = item.Attributes["href"].Name;
             }
             else
             {
             hedgingParty.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNodeList collateralNodeList = xmlNode.SelectNodes("collateral");
     if (collateralNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in collateralNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 collateralIDRef = item.Attributes["id"].Name;
                 Collateral ob = Collateral();
                 IDManager.SetID(collateralIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 collateralIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 collateral = new Collateral(item);
             }
         }
     }
     
 
     XmlNodeList documentationNodeList = xmlNode.SelectNodes("documentation");
     if (documentationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in documentationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 documentationIDRef = item.Attributes["id"].Name;
                 Documentation ob = Documentation();
                 IDManager.SetID(documentationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 documentationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 documentation = new Documentation(item);
             }
         }
     }
     
 
     XmlNodeList governingLawNodeList = xmlNode.SelectNodes("governingLaw");
     if (governingLawNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in governingLawNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 governingLawIDRef = item.Attributes["id"].Name;
                 GoverningLaw ob = GoverningLaw();
                 IDManager.SetID(governingLawIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 governingLawIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 governingLaw = new GoverningLaw(item);
             }
         }
     }
     
 
     XmlNodeList allocationsNodeList = xmlNode.SelectNodes("allocations");
     if (allocationsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in allocationsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocationsIDRef = item.Attributes["id"].Name;
                 Allocations ob = Allocations();
                 IDManager.SetID(allocationsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocationsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 allocations = new Allocations(item);
             }
         }
     }
     
 
 }
        public OptionalEarlyTermination(XmlNode xmlNode)
        {
            XmlNode singlePartyOptionNode = xmlNode.SelectSingleNode("singlePartyOption");

            if (singlePartyOptionNode != null)
            {
                if (singlePartyOptionNode.Attributes["href"] != null || singlePartyOptionNode.Attributes["id"] != null)
                {
                    if (singlePartyOptionNode.Attributes["id"] != null)
                    {
                        singlePartyOptionIDRef_ = singlePartyOptionNode.Attributes["id"].Value;
                        SinglePartyOption ob = new SinglePartyOption(singlePartyOptionNode);
                        IDManager.SetID(singlePartyOptionIDRef_, ob);
                    }
                    else if (singlePartyOptionNode.Attributes["href"] != null)
                    {
                        singlePartyOptionIDRef_ = singlePartyOptionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        singlePartyOption_ = new SinglePartyOption(singlePartyOptionNode);
                    }
                }
                else
                {
                    singlePartyOption_ = new SinglePartyOption(singlePartyOptionNode);
                }
            }


            XmlNode exerciseNode = xmlNode.SelectSingleNode("exercise");

            if (exerciseNode != null)
            {
                if (exerciseNode.Attributes["href"] != null || exerciseNode.Attributes["id"] != null)
                {
                    if (exerciseNode.Attributes["id"] != null)
                    {
                        exerciseIDRef_ = exerciseNode.Attributes["id"].Value;
                        Exercise ob = new Exercise(exerciseNode);
                        IDManager.SetID(exerciseIDRef_, ob);
                    }
                    else if (exerciseNode.Attributes["href"] != null)
                    {
                        exerciseIDRef_ = exerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        exercise_ = new Exercise(exerciseNode);
                    }
                }
                else
                {
                    exercise_ = new Exercise(exerciseNode);
                }
            }


            XmlNode americanExerciseNode = xmlNode.SelectSingleNode("americanExercise");

            if (americanExerciseNode != null)
            {
                if (americanExerciseNode.Attributes["href"] != null || americanExerciseNode.Attributes["id"] != null)
                {
                    if (americanExerciseNode.Attributes["id"] != null)
                    {
                        americanExerciseIDRef_ = americanExerciseNode.Attributes["id"].Value;
                        AmericanExercise ob = new AmericanExercise(americanExerciseNode);
                        IDManager.SetID(americanExerciseIDRef_, ob);
                    }
                    else if (americanExerciseNode.Attributes["href"] != null)
                    {
                        americanExerciseIDRef_ = americanExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        americanExercise_ = new AmericanExercise(americanExerciseNode);
                    }
                }
                else
                {
                    americanExercise_ = new AmericanExercise(americanExerciseNode);
                }
            }


            XmlNode bermudaExerciseNode = xmlNode.SelectSingleNode("bermudaExercise");

            if (bermudaExerciseNode != null)
            {
                if (bermudaExerciseNode.Attributes["href"] != null || bermudaExerciseNode.Attributes["id"] != null)
                {
                    if (bermudaExerciseNode.Attributes["id"] != null)
                    {
                        bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["id"].Value;
                        BermudaExercise ob = new BermudaExercise(bermudaExerciseNode);
                        IDManager.SetID(bermudaExerciseIDRef_, ob);
                    }
                    else if (bermudaExerciseNode.Attributes["href"] != null)
                    {
                        bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
                    }
                }
                else
                {
                    bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
                }
            }


            XmlNode europeanExerciseNode = xmlNode.SelectSingleNode("europeanExercise");

            if (europeanExerciseNode != null)
            {
                if (europeanExerciseNode.Attributes["href"] != null || europeanExerciseNode.Attributes["id"] != null)
                {
                    if (europeanExerciseNode.Attributes["id"] != null)
                    {
                        europeanExerciseIDRef_ = europeanExerciseNode.Attributes["id"].Value;
                        EuropeanExercise ob = new EuropeanExercise(europeanExerciseNode);
                        IDManager.SetID(europeanExerciseIDRef_, ob);
                    }
                    else if (europeanExerciseNode.Attributes["href"] != null)
                    {
                        europeanExerciseIDRef_ = europeanExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
                    }
                }
                else
                {
                    europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
                }
            }


            XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");

            if (exerciseNoticeNodeList != null)
            {
                this.exerciseNotice_ = new List <ExerciseNotice>();
                foreach (XmlNode item in exerciseNoticeNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            exerciseNoticeIDRef_ = item.Attributes["id"].Value;
                            exerciseNotice_.Add(new ExerciseNotice(item));
                            IDManager.SetID(exerciseNoticeIDRef_, exerciseNotice_[exerciseNotice_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            exerciseNoticeIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            exerciseNotice_.Add(new ExerciseNotice(item));
                        }
                    }
                    else
                    {
                        exerciseNotice_.Add(new ExerciseNotice(item));
                    }
                }
            }


            XmlNode followUpConfirmationNode = xmlNode.SelectSingleNode("followUpConfirmation");

            if (followUpConfirmationNode != null)
            {
                if (followUpConfirmationNode.Attributes["href"] != null || followUpConfirmationNode.Attributes["id"] != null)
                {
                    if (followUpConfirmationNode.Attributes["id"] != null)
                    {
                        followUpConfirmationIDRef_ = followUpConfirmationNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(followUpConfirmationNode);
                        IDManager.SetID(followUpConfirmationIDRef_, ob);
                    }
                    else if (followUpConfirmationNode.Attributes["href"] != null)
                    {
                        followUpConfirmationIDRef_ = followUpConfirmationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        followUpConfirmation_ = new XsdTypeBoolean(followUpConfirmationNode);
                    }
                }
                else
                {
                    followUpConfirmation_ = new XsdTypeBoolean(followUpConfirmationNode);
                }
            }


            XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");

            if (calculationAgentNode != null)
            {
                if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null)
                {
                    if (calculationAgentNode.Attributes["id"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                        CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                        IDManager.SetID(calculationAgentIDRef_, ob);
                    }
                    else if (calculationAgentNode.Attributes["href"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAgent_ = new CalculationAgent(calculationAgentNode);
                    }
                }
                else
                {
                    calculationAgent_ = new CalculationAgent(calculationAgentNode);
                }
            }


            XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");

            if (cashSettlementNode != null)
            {
                if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null)
                {
                    if (cashSettlementNode.Attributes["id"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                        CashSettlement ob = new CashSettlement(cashSettlementNode);
                        IDManager.SetID(cashSettlementIDRef_, ob);
                    }
                    else if (cashSettlementNode.Attributes["href"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashSettlement_ = new CashSettlement(cashSettlementNode);
                    }
                }
                else
                {
                    cashSettlement_ = new CashSettlement(cashSettlementNode);
                }
            }


            XmlNode optionalEarlyTerminationAdjustedDatesNode = xmlNode.SelectSingleNode("optionalEarlyTerminationAdjustedDates");

            if (optionalEarlyTerminationAdjustedDatesNode != null)
            {
                if (optionalEarlyTerminationAdjustedDatesNode.Attributes["href"] != null || optionalEarlyTerminationAdjustedDatesNode.Attributes["id"] != null)
                {
                    if (optionalEarlyTerminationAdjustedDatesNode.Attributes["id"] != null)
                    {
                        optionalEarlyTerminationAdjustedDatesIDRef_ = optionalEarlyTerminationAdjustedDatesNode.Attributes["id"].Value;
                        OptionalEarlyTerminationAdjustedDates ob = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
                        IDManager.SetID(optionalEarlyTerminationAdjustedDatesIDRef_, ob);
                    }
                    else if (optionalEarlyTerminationAdjustedDatesNode.Attributes["href"] != null)
                    {
                        optionalEarlyTerminationAdjustedDatesIDRef_ = optionalEarlyTerminationAdjustedDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        optionalEarlyTerminationAdjustedDates_ = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
                    }
                }
                else
                {
                    optionalEarlyTerminationAdjustedDates_ = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
                }
            }
        }
        public OptionalEarlyTermination(XmlNode xmlNode)
        {
            XmlNodeList singlePartyOptionNodeList = xmlNode.SelectNodes("singlePartyOption");

            if (singlePartyOptionNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in singlePartyOptionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        singlePartyOptionIDRef = item.Attributes["id"].Name;
                        SinglePartyOption ob = SinglePartyOption();
                        IDManager.SetID(singlePartyOptionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        singlePartyOptionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        singlePartyOption = new SinglePartyOption(item);
                    }
                }
            }


            XmlNodeList exerciseNodeList = xmlNode.SelectNodes("exercise");

            if (exerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in exerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exerciseIDRef = item.Attributes["id"].Name;
                        Exercise ob = Exercise();
                        IDManager.SetID(exerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exercise = new Exercise(item);
                    }
                }
            }


            XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");

            if (americanExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in americanExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        americanExerciseIDRef = item.Attributes["id"].Name;
                        AmericanExercise ob = AmericanExercise();
                        IDManager.SetID(americanExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        americanExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        americanExercise = new AmericanExercise(item);
                    }
                }
            }


            XmlNodeList bermudaExerciseNodeList = xmlNode.SelectNodes("bermudaExercise");

            if (bermudaExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in bermudaExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        bermudaExerciseIDRef = item.Attributes["id"].Name;
                        BermudaExercise ob = BermudaExercise();
                        IDManager.SetID(bermudaExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        bermudaExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        bermudaExercise = new BermudaExercise(item);
                    }
                }
            }


            XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");

            if (europeanExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in europeanExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        europeanExerciseIDRef = item.Attributes["id"].Name;
                        EuropeanExercise ob = EuropeanExercise();
                        IDManager.SetID(europeanExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        europeanExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        europeanExercise = new EuropeanExercise(item);
                    }
                }
            }


            XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");

            foreach (XmlNode item in exerciseNoticeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exerciseNoticeIDRef = item.Attributes["id"].Name;
                        List <ExerciseNotice> ob = new List <ExerciseNotice>();
                        ob.Add(new ExerciseNotice(item));
                        IDManager.SetID(exerciseNoticeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exerciseNoticeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exerciseNotice.Add(new ExerciseNotice(item));
                    }
                }
            }


            XmlNodeList followUpConfirmationNodeList = xmlNode.SelectNodes("followUpConfirmation");

            if (followUpConfirmationNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in followUpConfirmationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        followUpConfirmationIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(followUpConfirmationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        followUpConfirmationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        followUpConfirmation = new XsdTypeBoolean(item);
                    }
                }
            }


            XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");

            if (calculationAgentNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in calculationAgentNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        calculationAgentIDRef = item.Attributes["id"].Name;
                        CalculationAgent ob = CalculationAgent();
                        IDManager.SetID(calculationAgentIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        calculationAgentIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        calculationAgent = new CalculationAgent(item);
                    }
                }
            }


            XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");

            if (cashSettlementNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in cashSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashSettlementIDRef = item.Attributes["id"].Name;
                        CashSettlement ob = CashSettlement();
                        IDManager.SetID(cashSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashSettlement = new CashSettlement(item);
                    }
                }
            }


            XmlNodeList optionalEarlyTerminationAdjustedDatesNodeList = xmlNode.SelectNodes("optionalEarlyTerminationAdjustedDates");

            if (optionalEarlyTerminationAdjustedDatesNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in optionalEarlyTerminationAdjustedDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        optionalEarlyTerminationAdjustedDatesIDRef = item.Attributes["id"].Name;
                        OptionalEarlyTerminationAdjustedDates ob = OptionalEarlyTerminationAdjustedDates();
                        IDManager.SetID(optionalEarlyTerminationAdjustedDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        optionalEarlyTerminationAdjustedDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        optionalEarlyTerminationAdjustedDates = new OptionalEarlyTerminationAdjustedDates(item);
                    }
                }
            }
        }
 public MandatoryEarlyTermination(XmlNode xmlNode)
 {
     XmlNode mandatoryEarlyTerminationDateNode = xmlNode.SelectSingleNode("mandatoryEarlyTerminationDate");
     
     if (mandatoryEarlyTerminationDateNode != null)
     {
         if (mandatoryEarlyTerminationDateNode.Attributes["href"] != null || mandatoryEarlyTerminationDateNode.Attributes["id"] != null) 
         {
             if (mandatoryEarlyTerminationDateNode.Attributes["id"] != null) 
             {
                 mandatoryEarlyTerminationDateIDRef_ = mandatoryEarlyTerminationDateNode.Attributes["id"].Value;
                 AdjustableDate ob = new AdjustableDate(mandatoryEarlyTerminationDateNode);
                 IDManager.SetID(mandatoryEarlyTerminationDateIDRef_, ob);
             }
             else if (mandatoryEarlyTerminationDateNode.Attributes["href"] != null)
             {
                 mandatoryEarlyTerminationDateIDRef_ = mandatoryEarlyTerminationDateNode.Attributes["href"].Value;
             }
             else
             {
                 mandatoryEarlyTerminationDate_ = new AdjustableDate(mandatoryEarlyTerminationDateNode);
             }
         }
         else
         {
             mandatoryEarlyTerminationDate_ = new AdjustableDate(mandatoryEarlyTerminationDateNode);
         }
     }
     
 
     XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");
     
     if (calculationAgentNode != null)
     {
         if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null) 
         {
             if (calculationAgentNode.Attributes["id"] != null) 
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                 CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                 IDManager.SetID(calculationAgentIDRef_, ob);
             }
             else if (calculationAgentNode.Attributes["href"] != null)
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgent_ = new CalculationAgent(calculationAgentNode);
             }
         }
         else
         {
             calculationAgent_ = new CalculationAgent(calculationAgentNode);
         }
     }
     
 
     XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");
     
     if (cashSettlementNode != null)
     {
         if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null) 
         {
             if (cashSettlementNode.Attributes["id"] != null) 
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                 CashSettlement ob = new CashSettlement(cashSettlementNode);
                 IDManager.SetID(cashSettlementIDRef_, ob);
             }
             else if (cashSettlementNode.Attributes["href"] != null)
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 cashSettlement_ = new CashSettlement(cashSettlementNode);
             }
         }
         else
         {
             cashSettlement_ = new CashSettlement(cashSettlementNode);
         }
     }
     
 
     XmlNode mandatoryEarlyTerminationAdjustedDatesNode = xmlNode.SelectSingleNode("mandatoryEarlyTerminationAdjustedDates");
     
     if (mandatoryEarlyTerminationAdjustedDatesNode != null)
     {
         if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"] != null || mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"] != null) 
         {
             if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"] != null) 
             {
                 mandatoryEarlyTerminationAdjustedDatesIDRef_ = mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"].Value;
                 MandatoryEarlyTerminationAdjustedDates ob = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
                 IDManager.SetID(mandatoryEarlyTerminationAdjustedDatesIDRef_, ob);
             }
             else if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"] != null)
             {
                 mandatoryEarlyTerminationAdjustedDatesIDRef_ = mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"].Value;
             }
             else
             {
                 mandatoryEarlyTerminationAdjustedDates_ = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
             }
         }
         else
         {
             mandatoryEarlyTerminationAdjustedDates_ = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
         }
     }
     
 
 }
        public FallbackReferencePrice(XmlNode xmlNode)
        {
            XmlNode valuationPostponementNode = xmlNode.SelectSingleNode("valuationPostponement");

            if (valuationPostponementNode != null)
            {
                if (valuationPostponementNode.Attributes["href"] != null || valuationPostponementNode.Attributes["id"] != null)
                {
                    if (valuationPostponementNode.Attributes["id"] != null)
                    {
                        valuationPostponementIDRef_ = valuationPostponementNode.Attributes["id"].Value;
                        ValuationPostponement ob = new ValuationPostponement(valuationPostponementNode);
                        IDManager.SetID(valuationPostponementIDRef_, ob);
                    }
                    else if (valuationPostponementNode.Attributes["href"] != null)
                    {
                        valuationPostponementIDRef_ = valuationPostponementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationPostponement_ = new ValuationPostponement(valuationPostponementNode);
                    }
                }
                else
                {
                    valuationPostponement_ = new ValuationPostponement(valuationPostponementNode);
                }
            }


            XmlNodeList fallbackSettlementRateOptionNodeList = xmlNode.SelectNodes("fallbackSettlementRateOption");

            if (fallbackSettlementRateOptionNodeList != null)
            {
                this.fallbackSettlementRateOption_ = new List <SettlementRateOption>();
                foreach (XmlNode item in fallbackSettlementRateOptionNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            fallbackSettlementRateOptionIDRef_ = item.Attributes["id"].Value;
                            fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
                            IDManager.SetID(fallbackSettlementRateOptionIDRef_, fallbackSettlementRateOption_[fallbackSettlementRateOption_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            fallbackSettlementRateOptionIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
                        }
                    }
                    else
                    {
                        fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
                    }
                }
            }


            XmlNode fallbackSurveyValuationPostponenmentNode = xmlNode.SelectSingleNode("fallbackSurveyValuationPostponenment");

            if (fallbackSurveyValuationPostponenmentNode != null)
            {
                if (fallbackSurveyValuationPostponenmentNode.Attributes["href"] != null || fallbackSurveyValuationPostponenmentNode.Attributes["id"] != null)
                {
                    if (fallbackSurveyValuationPostponenmentNode.Attributes["id"] != null)
                    {
                        fallbackSurveyValuationPostponenmentIDRef_ = fallbackSurveyValuationPostponenmentNode.Attributes["id"].Value;
                        Empty ob = new Empty(fallbackSurveyValuationPostponenmentNode);
                        IDManager.SetID(fallbackSurveyValuationPostponenmentIDRef_, ob);
                    }
                    else if (fallbackSurveyValuationPostponenmentNode.Attributes["href"] != null)
                    {
                        fallbackSurveyValuationPostponenmentIDRef_ = fallbackSurveyValuationPostponenmentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fallbackSurveyValuationPostponenment_ = new Empty(fallbackSurveyValuationPostponenmentNode);
                    }
                }
                else
                {
                    fallbackSurveyValuationPostponenment_ = new Empty(fallbackSurveyValuationPostponenmentNode);
                }
            }


            XmlNode calculationAgentDeterminationNode = xmlNode.SelectSingleNode("calculationAgentDetermination");

            if (calculationAgentDeterminationNode != null)
            {
                if (calculationAgentDeterminationNode.Attributes["href"] != null || calculationAgentDeterminationNode.Attributes["id"] != null)
                {
                    if (calculationAgentDeterminationNode.Attributes["id"] != null)
                    {
                        calculationAgentDeterminationIDRef_ = calculationAgentDeterminationNode.Attributes["id"].Value;
                        CalculationAgent ob = new CalculationAgent(calculationAgentDeterminationNode);
                        IDManager.SetID(calculationAgentDeterminationIDRef_, ob);
                    }
                    else if (calculationAgentDeterminationNode.Attributes["href"] != null)
                    {
                        calculationAgentDeterminationIDRef_ = calculationAgentDeterminationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAgentDetermination_ = new CalculationAgent(calculationAgentDeterminationNode);
                    }
                }
                else
                {
                    calculationAgentDetermination_ = new CalculationAgent(calculationAgentDeterminationNode);
                }
            }
        }
 public Swaption(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 premiumNodeList = xmlNode.SelectNodes("premium");
     
     foreach (XmlNode item in premiumNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 premiumIDRef = item.Attributes["id"].Name;
                 List<Payment> ob = new List<Payment>();
                 ob.Add(new Payment(item));
                 IDManager.SetID(premiumIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 premiumIDRef = item.Attributes["href"].Name;
             }
             else
             {
             premium.Add(new Payment(item));
             }
         }
     }
     
 
     XmlNodeList exerciseNodeList = xmlNode.SelectNodes("exercise");
     if (exerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseIDRef = item.Attributes["id"].Name;
                 Exercise ob = Exercise();
                 IDManager.SetID(exerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exercise = new Exercise(item);
             }
         }
     }
     
 
     XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");
     if (americanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in americanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 americanExerciseIDRef = item.Attributes["id"].Name;
                 AmericanExercise ob = AmericanExercise();
                 IDManager.SetID(americanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 americanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 americanExercise = new AmericanExercise(item);
             }
         }
     }
     
 
     XmlNodeList bermudaExerciseNodeList = xmlNode.SelectNodes("bermudaExercise");
     if (bermudaExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bermudaExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bermudaExerciseIDRef = item.Attributes["id"].Name;
                 BermudaExercise ob = BermudaExercise();
                 IDManager.SetID(bermudaExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bermudaExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bermudaExercise = new BermudaExercise(item);
             }
         }
     }
     
 
     XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");
     if (europeanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in europeanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef = item.Attributes["id"].Name;
                 EuropeanExercise ob = EuropeanExercise();
                 IDManager.SetID(europeanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 europeanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 europeanExercise = new EuropeanExercise(item);
             }
         }
     }
     
 
     XmlNodeList exerciseProcedureNodeList = xmlNode.SelectNodes("exerciseProcedure");
     if (exerciseProcedureNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseProcedureNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseProcedureIDRef = item.Attributes["id"].Name;
                 ExerciseProcedure ob = ExerciseProcedure();
                 IDManager.SetID(exerciseProcedureIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseProcedureIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exerciseProcedure = new ExerciseProcedure(item);
             }
         }
     }
     
 
     XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");
     if (calculationAgentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentIDRef = item.Attributes["id"].Name;
                 CalculationAgent ob = CalculationAgent();
                 IDManager.SetID(calculationAgentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgent = new CalculationAgent(item);
             }
         }
     }
     
 
     XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");
     if (cashSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementIDRef = item.Attributes["id"].Name;
                 CashSettlement ob = CashSettlement();
                 IDManager.SetID(cashSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlement = new CashSettlement(item);
             }
         }
     }
     
 
     XmlNodeList physicalSettlementNodeList = xmlNode.SelectNodes("physicalSettlement");
     if (physicalSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in physicalSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 physicalSettlementIDRef = item.Attributes["id"].Name;
                 SwaptionPhysicalSettlement ob = SwaptionPhysicalSettlement();
                 IDManager.SetID(physicalSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 physicalSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 physicalSettlement = new SwaptionPhysicalSettlement(item);
             }
         }
     }
     
 
     XmlNodeList swaptionStraddleNodeList = xmlNode.SelectNodes("swaptionStraddle");
     if (swaptionStraddleNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swaptionStraddleNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swaptionStraddleIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(swaptionStraddleIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swaptionStraddleIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swaptionStraddle = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList swaptionAdjustedDatesNodeList = xmlNode.SelectNodes("swaptionAdjustedDates");
     if (swaptionAdjustedDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swaptionAdjustedDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swaptionAdjustedDatesIDRef = item.Attributes["id"].Name;
                 SwaptionAdjustedDates ob = SwaptionAdjustedDates();
                 IDManager.SetID(swaptionAdjustedDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swaptionAdjustedDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swaptionAdjustedDates = new SwaptionAdjustedDates(item);
             }
         }
     }
     
 
     XmlNodeList swapNodeList = xmlNode.SelectNodes("swap");
     if (swapNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in swapNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 swapIDRef = item.Attributes["id"].Name;
                 Swap ob = Swap();
                 IDManager.SetID(swapIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 swapIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 swap = new Swap(item);
             }
         }
     }
     
 
 }
        public MandatoryEarlyTermination(XmlNode xmlNode)
        {
            XmlNodeList mandatoryEarlyTerminationDateNodeList = xmlNode.SelectNodes("mandatoryEarlyTerminationDate");

            if (mandatoryEarlyTerminationDateNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in mandatoryEarlyTerminationDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        mandatoryEarlyTerminationDateIDRef = item.Attributes["id"].Name;
                        AdjustableDate ob = AdjustableDate();
                        IDManager.SetID(mandatoryEarlyTerminationDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        mandatoryEarlyTerminationDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        mandatoryEarlyTerminationDate = new AdjustableDate(item);
                    }
                }
            }


            XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");

            if (calculationAgentNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in calculationAgentNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        calculationAgentIDRef = item.Attributes["id"].Name;
                        CalculationAgent ob = CalculationAgent();
                        IDManager.SetID(calculationAgentIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        calculationAgentIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        calculationAgent = new CalculationAgent(item);
                    }
                }
            }


            XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");

            if (cashSettlementNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in cashSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashSettlementIDRef = item.Attributes["id"].Name;
                        CashSettlement ob = CashSettlement();
                        IDManager.SetID(cashSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashSettlement = new CashSettlement(item);
                    }
                }
            }


            XmlNodeList mandatoryEarlyTerminationAdjustedDatesNodeList = xmlNode.SelectNodes("mandatoryEarlyTerminationAdjustedDates");

            if (mandatoryEarlyTerminationAdjustedDatesNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in mandatoryEarlyTerminationAdjustedDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        mandatoryEarlyTerminationAdjustedDatesIDRef = item.Attributes["id"].Name;
                        MandatoryEarlyTerminationAdjustedDates ob = MandatoryEarlyTerminationAdjustedDates();
                        IDManager.SetID(mandatoryEarlyTerminationAdjustedDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        mandatoryEarlyTerminationAdjustedDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        mandatoryEarlyTerminationAdjustedDates = new MandatoryEarlyTerminationAdjustedDates(item);
                    }
                }
            }
        }
Example #11
0
        public MandatoryEarlyTermination(XmlNode xmlNode)
        {
            XmlNode mandatoryEarlyTerminationDateNode = xmlNode.SelectSingleNode("mandatoryEarlyTerminationDate");

            if (mandatoryEarlyTerminationDateNode != null)
            {
                if (mandatoryEarlyTerminationDateNode.Attributes["href"] != null || mandatoryEarlyTerminationDateNode.Attributes["id"] != null)
                {
                    if (mandatoryEarlyTerminationDateNode.Attributes["id"] != null)
                    {
                        mandatoryEarlyTerminationDateIDRef_ = mandatoryEarlyTerminationDateNode.Attributes["id"].Value;
                        AdjustableDate ob = new AdjustableDate(mandatoryEarlyTerminationDateNode);
                        IDManager.SetID(mandatoryEarlyTerminationDateIDRef_, ob);
                    }
                    else if (mandatoryEarlyTerminationDateNode.Attributes["href"] != null)
                    {
                        mandatoryEarlyTerminationDateIDRef_ = mandatoryEarlyTerminationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        mandatoryEarlyTerminationDate_ = new AdjustableDate(mandatoryEarlyTerminationDateNode);
                    }
                }
                else
                {
                    mandatoryEarlyTerminationDate_ = new AdjustableDate(mandatoryEarlyTerminationDateNode);
                }
            }


            XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");

            if (calculationAgentNode != null)
            {
                if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null)
                {
                    if (calculationAgentNode.Attributes["id"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                        CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                        IDManager.SetID(calculationAgentIDRef_, ob);
                    }
                    else if (calculationAgentNode.Attributes["href"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAgent_ = new CalculationAgent(calculationAgentNode);
                    }
                }
                else
                {
                    calculationAgent_ = new CalculationAgent(calculationAgentNode);
                }
            }


            XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");

            if (cashSettlementNode != null)
            {
                if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null)
                {
                    if (cashSettlementNode.Attributes["id"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                        CashSettlement ob = new CashSettlement(cashSettlementNode);
                        IDManager.SetID(cashSettlementIDRef_, ob);
                    }
                    else if (cashSettlementNode.Attributes["href"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashSettlement_ = new CashSettlement(cashSettlementNode);
                    }
                }
                else
                {
                    cashSettlement_ = new CashSettlement(cashSettlementNode);
                }
            }


            XmlNode mandatoryEarlyTerminationAdjustedDatesNode = xmlNode.SelectSingleNode("mandatoryEarlyTerminationAdjustedDates");

            if (mandatoryEarlyTerminationAdjustedDatesNode != null)
            {
                if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"] != null || mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"] != null)
                {
                    if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"] != null)
                    {
                        mandatoryEarlyTerminationAdjustedDatesIDRef_ = mandatoryEarlyTerminationAdjustedDatesNode.Attributes["id"].Value;
                        MandatoryEarlyTerminationAdjustedDates ob = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
                        IDManager.SetID(mandatoryEarlyTerminationAdjustedDatesIDRef_, ob);
                    }
                    else if (mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"] != null)
                    {
                        mandatoryEarlyTerminationAdjustedDatesIDRef_ = mandatoryEarlyTerminationAdjustedDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        mandatoryEarlyTerminationAdjustedDates_ = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
                    }
                }
                else
                {
                    mandatoryEarlyTerminationAdjustedDates_ = new MandatoryEarlyTerminationAdjustedDates(mandatoryEarlyTerminationAdjustedDatesNode);
                }
            }
        }
        public Swaption(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 premiumNodeList = xmlNode.SelectNodes("premium");

            foreach (XmlNode item in premiumNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        premiumIDRef = item.Attributes["id"].Name;
                        List <Payment> ob = new List <Payment>();
                        ob.Add(new Payment(item));
                        IDManager.SetID(premiumIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        premiumIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        premium.Add(new Payment(item));
                    }
                }
            }


            XmlNodeList exerciseNodeList = xmlNode.SelectNodes("exercise");

            if (exerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in exerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exerciseIDRef = item.Attributes["id"].Name;
                        Exercise ob = Exercise();
                        IDManager.SetID(exerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exercise = new Exercise(item);
                    }
                }
            }


            XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");

            if (americanExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in americanExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        americanExerciseIDRef = item.Attributes["id"].Name;
                        AmericanExercise ob = AmericanExercise();
                        IDManager.SetID(americanExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        americanExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        americanExercise = new AmericanExercise(item);
                    }
                }
            }


            XmlNodeList bermudaExerciseNodeList = xmlNode.SelectNodes("bermudaExercise");

            if (bermudaExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in bermudaExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        bermudaExerciseIDRef = item.Attributes["id"].Name;
                        BermudaExercise ob = BermudaExercise();
                        IDManager.SetID(bermudaExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        bermudaExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        bermudaExercise = new BermudaExercise(item);
                    }
                }
            }


            XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");

            if (europeanExerciseNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in europeanExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        europeanExerciseIDRef = item.Attributes["id"].Name;
                        EuropeanExercise ob = EuropeanExercise();
                        IDManager.SetID(europeanExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        europeanExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        europeanExercise = new EuropeanExercise(item);
                    }
                }
            }


            XmlNodeList exerciseProcedureNodeList = xmlNode.SelectNodes("exerciseProcedure");

            if (exerciseProcedureNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in exerciseProcedureNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exerciseProcedureIDRef = item.Attributes["id"].Name;
                        ExerciseProcedure ob = ExerciseProcedure();
                        IDManager.SetID(exerciseProcedureIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exerciseProcedureIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exerciseProcedure = new ExerciseProcedure(item);
                    }
                }
            }


            XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");

            if (calculationAgentNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in calculationAgentNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        calculationAgentIDRef = item.Attributes["id"].Name;
                        CalculationAgent ob = CalculationAgent();
                        IDManager.SetID(calculationAgentIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        calculationAgentIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        calculationAgent = new CalculationAgent(item);
                    }
                }
            }


            XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");

            if (cashSettlementNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in cashSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashSettlementIDRef = item.Attributes["id"].Name;
                        CashSettlement ob = CashSettlement();
                        IDManager.SetID(cashSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashSettlement = new CashSettlement(item);
                    }
                }
            }


            XmlNodeList physicalSettlementNodeList = xmlNode.SelectNodes("physicalSettlement");

            if (physicalSettlementNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in physicalSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        physicalSettlementIDRef = item.Attributes["id"].Name;
                        SwaptionPhysicalSettlement ob = SwaptionPhysicalSettlement();
                        IDManager.SetID(physicalSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        physicalSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        physicalSettlement = new SwaptionPhysicalSettlement(item);
                    }
                }
            }


            XmlNodeList swaptionStraddleNodeList = xmlNode.SelectNodes("swaptionStraddle");

            if (swaptionStraddleNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in swaptionStraddleNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        swaptionStraddleIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(swaptionStraddleIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        swaptionStraddleIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        swaptionStraddle = new XsdTypeBoolean(item);
                    }
                }
            }


            XmlNodeList swaptionAdjustedDatesNodeList = xmlNode.SelectNodes("swaptionAdjustedDates");

            if (swaptionAdjustedDatesNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in swaptionAdjustedDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        swaptionAdjustedDatesIDRef = item.Attributes["id"].Name;
                        SwaptionAdjustedDates ob = SwaptionAdjustedDates();
                        IDManager.SetID(swaptionAdjustedDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        swaptionAdjustedDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        swaptionAdjustedDates = new SwaptionAdjustedDates(item);
                    }
                }
            }


            XmlNodeList swapNodeList = xmlNode.SelectNodes("swap");

            if (swapNodeList.Count > 1)
            {
                throw new Exception();
            }

            foreach (XmlNode item in swapNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        swapIDRef = item.Attributes["id"].Name;
                        Swap ob = Swap();
                        IDManager.SetID(swapIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        swapIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        swap = new Swap(item);
                    }
                }
            }
        }
 public OptionalEarlyTermination(XmlNode xmlNode)
 {
     XmlNode singlePartyOptionNode = xmlNode.SelectSingleNode("singlePartyOption");
     
     if (singlePartyOptionNode != null)
     {
         if (singlePartyOptionNode.Attributes["href"] != null || singlePartyOptionNode.Attributes["id"] != null) 
         {
             if (singlePartyOptionNode.Attributes["id"] != null) 
             {
                 singlePartyOptionIDRef_ = singlePartyOptionNode.Attributes["id"].Value;
                 SinglePartyOption ob = new SinglePartyOption(singlePartyOptionNode);
                 IDManager.SetID(singlePartyOptionIDRef_, ob);
             }
             else if (singlePartyOptionNode.Attributes["href"] != null)
             {
                 singlePartyOptionIDRef_ = singlePartyOptionNode.Attributes["href"].Value;
             }
             else
             {
                 singlePartyOption_ = new SinglePartyOption(singlePartyOptionNode);
             }
         }
         else
         {
             singlePartyOption_ = new SinglePartyOption(singlePartyOptionNode);
         }
     }
     
 
     XmlNode exerciseNode = xmlNode.SelectSingleNode("exercise");
     
     if (exerciseNode != null)
     {
         if (exerciseNode.Attributes["href"] != null || exerciseNode.Attributes["id"] != null) 
         {
             if (exerciseNode.Attributes["id"] != null) 
             {
                 exerciseIDRef_ = exerciseNode.Attributes["id"].Value;
                 Exercise ob = new Exercise(exerciseNode);
                 IDManager.SetID(exerciseIDRef_, ob);
             }
             else if (exerciseNode.Attributes["href"] != null)
             {
                 exerciseIDRef_ = exerciseNode.Attributes["href"].Value;
             }
             else
             {
                 exercise_ = new Exercise(exerciseNode);
             }
         }
         else
         {
             exercise_ = new Exercise(exerciseNode);
         }
     }
     
 
     XmlNode americanExerciseNode = xmlNode.SelectSingleNode("americanExercise");
     
     if (americanExerciseNode != null)
     {
         if (americanExerciseNode.Attributes["href"] != null || americanExerciseNode.Attributes["id"] != null) 
         {
             if (americanExerciseNode.Attributes["id"] != null) 
             {
                 americanExerciseIDRef_ = americanExerciseNode.Attributes["id"].Value;
                 AmericanExercise ob = new AmericanExercise(americanExerciseNode);
                 IDManager.SetID(americanExerciseIDRef_, ob);
             }
             else if (americanExerciseNode.Attributes["href"] != null)
             {
                 americanExerciseIDRef_ = americanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 americanExercise_ = new AmericanExercise(americanExerciseNode);
             }
         }
         else
         {
             americanExercise_ = new AmericanExercise(americanExerciseNode);
         }
     }
     
 
     XmlNode bermudaExerciseNode = xmlNode.SelectSingleNode("bermudaExercise");
     
     if (bermudaExerciseNode != null)
     {
         if (bermudaExerciseNode.Attributes["href"] != null || bermudaExerciseNode.Attributes["id"] != null) 
         {
             if (bermudaExerciseNode.Attributes["id"] != null) 
             {
                 bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["id"].Value;
                 BermudaExercise ob = new BermudaExercise(bermudaExerciseNode);
                 IDManager.SetID(bermudaExerciseIDRef_, ob);
             }
             else if (bermudaExerciseNode.Attributes["href"] != null)
             {
                 bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
             }
         }
         else
         {
             bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
         }
     }
     
 
     XmlNode europeanExerciseNode = xmlNode.SelectSingleNode("europeanExercise");
     
     if (europeanExerciseNode != null)
     {
         if (europeanExerciseNode.Attributes["href"] != null || europeanExerciseNode.Attributes["id"] != null) 
         {
             if (europeanExerciseNode.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef_ = europeanExerciseNode.Attributes["id"].Value;
                 EuropeanExercise ob = new EuropeanExercise(europeanExerciseNode);
                 IDManager.SetID(europeanExerciseIDRef_, ob);
             }
             else if (europeanExerciseNode.Attributes["href"] != null)
             {
                 europeanExerciseIDRef_ = europeanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
             }
         }
         else
         {
             europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
         }
     }
     
 
     XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");
     
     if (exerciseNoticeNodeList != null)
     {
         this.exerciseNotice_ = new List<ExerciseNotice>();
         foreach (XmlNode item in exerciseNoticeNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     exerciseNoticeIDRef_ = item.Attributes["id"].Value;
                     exerciseNotice_.Add(new ExerciseNotice(item));
                     IDManager.SetID(exerciseNoticeIDRef_, exerciseNotice_[exerciseNotice_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     exerciseNoticeIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 exerciseNotice_.Add(new ExerciseNotice(item));
                 }
             }
             else
             {
                 exerciseNotice_.Add(new ExerciseNotice(item));
             }
         }
     }
     
 
     XmlNode followUpConfirmationNode = xmlNode.SelectSingleNode("followUpConfirmation");
     
     if (followUpConfirmationNode != null)
     {
         if (followUpConfirmationNode.Attributes["href"] != null || followUpConfirmationNode.Attributes["id"] != null) 
         {
             if (followUpConfirmationNode.Attributes["id"] != null) 
             {
                 followUpConfirmationIDRef_ = followUpConfirmationNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(followUpConfirmationNode);
                 IDManager.SetID(followUpConfirmationIDRef_, ob);
             }
             else if (followUpConfirmationNode.Attributes["href"] != null)
             {
                 followUpConfirmationIDRef_ = followUpConfirmationNode.Attributes["href"].Value;
             }
             else
             {
                 followUpConfirmation_ = new XsdTypeBoolean(followUpConfirmationNode);
             }
         }
         else
         {
             followUpConfirmation_ = new XsdTypeBoolean(followUpConfirmationNode);
         }
     }
     
 
     XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");
     
     if (calculationAgentNode != null)
     {
         if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null) 
         {
             if (calculationAgentNode.Attributes["id"] != null) 
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                 CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                 IDManager.SetID(calculationAgentIDRef_, ob);
             }
             else if (calculationAgentNode.Attributes["href"] != null)
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgent_ = new CalculationAgent(calculationAgentNode);
             }
         }
         else
         {
             calculationAgent_ = new CalculationAgent(calculationAgentNode);
         }
     }
     
 
     XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");
     
     if (cashSettlementNode != null)
     {
         if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null) 
         {
             if (cashSettlementNode.Attributes["id"] != null) 
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                 CashSettlement ob = new CashSettlement(cashSettlementNode);
                 IDManager.SetID(cashSettlementIDRef_, ob);
             }
             else if (cashSettlementNode.Attributes["href"] != null)
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 cashSettlement_ = new CashSettlement(cashSettlementNode);
             }
         }
         else
         {
             cashSettlement_ = new CashSettlement(cashSettlementNode);
         }
     }
     
 
     XmlNode optionalEarlyTerminationAdjustedDatesNode = xmlNode.SelectSingleNode("optionalEarlyTerminationAdjustedDates");
     
     if (optionalEarlyTerminationAdjustedDatesNode != null)
     {
         if (optionalEarlyTerminationAdjustedDatesNode.Attributes["href"] != null || optionalEarlyTerminationAdjustedDatesNode.Attributes["id"] != null) 
         {
             if (optionalEarlyTerminationAdjustedDatesNode.Attributes["id"] != null) 
             {
                 optionalEarlyTerminationAdjustedDatesIDRef_ = optionalEarlyTerminationAdjustedDatesNode.Attributes["id"].Value;
                 OptionalEarlyTerminationAdjustedDates ob = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
                 IDManager.SetID(optionalEarlyTerminationAdjustedDatesIDRef_, ob);
             }
             else if (optionalEarlyTerminationAdjustedDatesNode.Attributes["href"] != null)
             {
                 optionalEarlyTerminationAdjustedDatesIDRef_ = optionalEarlyTerminationAdjustedDatesNode.Attributes["href"].Value;
             }
             else
             {
                 optionalEarlyTerminationAdjustedDates_ = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
             }
         }
         else
         {
             optionalEarlyTerminationAdjustedDates_ = new OptionalEarlyTerminationAdjustedDates(optionalEarlyTerminationAdjustedDatesNode);
         }
     }
     
 
 }
 public OptionalEarlyTermination(XmlNode xmlNode)
 {
     XmlNodeList singlePartyOptionNodeList = xmlNode.SelectNodes("singlePartyOption");
     if (singlePartyOptionNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in singlePartyOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 singlePartyOptionIDRef = item.Attributes["id"].Name;
                 SinglePartyOption ob = SinglePartyOption();
                 IDManager.SetID(singlePartyOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 singlePartyOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 singlePartyOption = new SinglePartyOption(item);
             }
         }
     }
     
 
     XmlNodeList exerciseNodeList = xmlNode.SelectNodes("exercise");
     if (exerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in exerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseIDRef = item.Attributes["id"].Name;
                 Exercise ob = Exercise();
                 IDManager.SetID(exerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 exercise = new Exercise(item);
             }
         }
     }
     
 
     XmlNodeList americanExerciseNodeList = xmlNode.SelectNodes("americanExercise");
     if (americanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in americanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 americanExerciseIDRef = item.Attributes["id"].Name;
                 AmericanExercise ob = AmericanExercise();
                 IDManager.SetID(americanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 americanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 americanExercise = new AmericanExercise(item);
             }
         }
     }
     
 
     XmlNodeList bermudaExerciseNodeList = xmlNode.SelectNodes("bermudaExercise");
     if (bermudaExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in bermudaExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 bermudaExerciseIDRef = item.Attributes["id"].Name;
                 BermudaExercise ob = BermudaExercise();
                 IDManager.SetID(bermudaExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 bermudaExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 bermudaExercise = new BermudaExercise(item);
             }
         }
     }
     
 
     XmlNodeList europeanExerciseNodeList = xmlNode.SelectNodes("europeanExercise");
     if (europeanExerciseNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in europeanExerciseNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef = item.Attributes["id"].Name;
                 EuropeanExercise ob = EuropeanExercise();
                 IDManager.SetID(europeanExerciseIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 europeanExerciseIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 europeanExercise = new EuropeanExercise(item);
             }
         }
     }
     
 
     XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");
     
     foreach (XmlNode item in exerciseNoticeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 exerciseNoticeIDRef = item.Attributes["id"].Name;
                 List<ExerciseNotice> ob = new List<ExerciseNotice>();
                 ob.Add(new ExerciseNotice(item));
                 IDManager.SetID(exerciseNoticeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 exerciseNoticeIDRef = item.Attributes["href"].Name;
             }
             else
             {
             exerciseNotice.Add(new ExerciseNotice(item));
             }
         }
     }
     
 
     XmlNodeList followUpConfirmationNodeList = xmlNode.SelectNodes("followUpConfirmation");
     if (followUpConfirmationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in followUpConfirmationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 followUpConfirmationIDRef = item.Attributes["id"].Name;
                 XsdTypeBoolean ob = XsdTypeBoolean();
                 IDManager.SetID(followUpConfirmationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 followUpConfirmationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 followUpConfirmation = new XsdTypeBoolean(item);
             }
         }
     }
     
 
     XmlNodeList calculationAgentNodeList = xmlNode.SelectNodes("calculationAgent");
     if (calculationAgentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentIDRef = item.Attributes["id"].Name;
                 CalculationAgent ob = CalculationAgent();
                 IDManager.SetID(calculationAgentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgent = new CalculationAgent(item);
             }
         }
     }
     
 
     XmlNodeList cashSettlementNodeList = xmlNode.SelectNodes("cashSettlement");
     if (cashSettlementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in cashSettlementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 cashSettlementIDRef = item.Attributes["id"].Name;
                 CashSettlement ob = CashSettlement();
                 IDManager.SetID(cashSettlementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 cashSettlementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 cashSettlement = new CashSettlement(item);
             }
         }
     }
     
 
     XmlNodeList optionalEarlyTerminationAdjustedDatesNodeList = xmlNode.SelectNodes("optionalEarlyTerminationAdjustedDates");
     if (optionalEarlyTerminationAdjustedDatesNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in optionalEarlyTerminationAdjustedDatesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 optionalEarlyTerminationAdjustedDatesIDRef = item.Attributes["id"].Name;
                 OptionalEarlyTerminationAdjustedDates ob = OptionalEarlyTerminationAdjustedDates();
                 IDManager.SetID(optionalEarlyTerminationAdjustedDatesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 optionalEarlyTerminationAdjustedDatesIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 optionalEarlyTerminationAdjustedDates = new OptionalEarlyTerminationAdjustedDates(item);
             }
         }
     }
     
 
 }
        public Swaption(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode buyerPartyReferenceNode = xmlNode.SelectSingleNode("buyerPartyReference");

            if (buyerPartyReferenceNode != null)
            {
                if (buyerPartyReferenceNode.Attributes["href"] != null || buyerPartyReferenceNode.Attributes["id"] != null)
                {
                    if (buyerPartyReferenceNode.Attributes["id"] != null)
                    {
                        buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["id"].Value;
                        PartyReference ob = new PartyReference(buyerPartyReferenceNode);
                        IDManager.SetID(buyerPartyReferenceIDRef_, ob);
                    }
                    else if (buyerPartyReferenceNode.Attributes["href"] != null)
                    {
                        buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
                    }
                }
                else
                {
                    buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
                }
            }


            XmlNode buyerAccountReferenceNode = xmlNode.SelectSingleNode("buyerAccountReference");

            if (buyerAccountReferenceNode != null)
            {
                if (buyerAccountReferenceNode.Attributes["href"] != null || buyerAccountReferenceNode.Attributes["id"] != null)
                {
                    if (buyerAccountReferenceNode.Attributes["id"] != null)
                    {
                        buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["id"].Value;
                        AccountReference ob = new AccountReference(buyerAccountReferenceNode);
                        IDManager.SetID(buyerAccountReferenceIDRef_, ob);
                    }
                    else if (buyerAccountReferenceNode.Attributes["href"] != null)
                    {
                        buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
                    }
                }
                else
                {
                    buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
                }
            }


            XmlNode sellerPartyReferenceNode = xmlNode.SelectSingleNode("sellerPartyReference");

            if (sellerPartyReferenceNode != null)
            {
                if (sellerPartyReferenceNode.Attributes["href"] != null || sellerPartyReferenceNode.Attributes["id"] != null)
                {
                    if (sellerPartyReferenceNode.Attributes["id"] != null)
                    {
                        sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["id"].Value;
                        PartyReference ob = new PartyReference(sellerPartyReferenceNode);
                        IDManager.SetID(sellerPartyReferenceIDRef_, ob);
                    }
                    else if (sellerPartyReferenceNode.Attributes["href"] != null)
                    {
                        sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
                    }
                }
                else
                {
                    sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
                }
            }


            XmlNode sellerAccountReferenceNode = xmlNode.SelectSingleNode("sellerAccountReference");

            if (sellerAccountReferenceNode != null)
            {
                if (sellerAccountReferenceNode.Attributes["href"] != null || sellerAccountReferenceNode.Attributes["id"] != null)
                {
                    if (sellerAccountReferenceNode.Attributes["id"] != null)
                    {
                        sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["id"].Value;
                        AccountReference ob = new AccountReference(sellerAccountReferenceNode);
                        IDManager.SetID(sellerAccountReferenceIDRef_, ob);
                    }
                    else if (sellerAccountReferenceNode.Attributes["href"] != null)
                    {
                        sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
                    }
                }
                else
                {
                    sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
                }
            }


            XmlNodeList premiumNodeList = xmlNode.SelectNodes("premium");

            if (premiumNodeList != null)
            {
                this.premium_ = new List <Payment>();
                foreach (XmlNode item in premiumNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            premiumIDRef_ = item.Attributes["id"].Value;
                            premium_.Add(new Payment(item));
                            IDManager.SetID(premiumIDRef_, premium_[premium_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            premiumIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            premium_.Add(new Payment(item));
                        }
                    }
                    else
                    {
                        premium_.Add(new Payment(item));
                    }
                }
            }


            XmlNode exerciseNode = xmlNode.SelectSingleNode("exercise");

            if (exerciseNode != null)
            {
                if (exerciseNode.Attributes["href"] != null || exerciseNode.Attributes["id"] != null)
                {
                    if (exerciseNode.Attributes["id"] != null)
                    {
                        exerciseIDRef_ = exerciseNode.Attributes["id"].Value;
                        Exercise ob = new Exercise(exerciseNode);
                        IDManager.SetID(exerciseIDRef_, ob);
                    }
                    else if (exerciseNode.Attributes["href"] != null)
                    {
                        exerciseIDRef_ = exerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        exercise_ = new Exercise(exerciseNode);
                    }
                }
                else
                {
                    exercise_ = new Exercise(exerciseNode);
                }
            }


            XmlNode americanExerciseNode = xmlNode.SelectSingleNode("americanExercise");

            if (americanExerciseNode != null)
            {
                if (americanExerciseNode.Attributes["href"] != null || americanExerciseNode.Attributes["id"] != null)
                {
                    if (americanExerciseNode.Attributes["id"] != null)
                    {
                        americanExerciseIDRef_ = americanExerciseNode.Attributes["id"].Value;
                        AmericanExercise ob = new AmericanExercise(americanExerciseNode);
                        IDManager.SetID(americanExerciseIDRef_, ob);
                    }
                    else if (americanExerciseNode.Attributes["href"] != null)
                    {
                        americanExerciseIDRef_ = americanExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        americanExercise_ = new AmericanExercise(americanExerciseNode);
                    }
                }
                else
                {
                    americanExercise_ = new AmericanExercise(americanExerciseNode);
                }
            }


            XmlNode bermudaExerciseNode = xmlNode.SelectSingleNode("bermudaExercise");

            if (bermudaExerciseNode != null)
            {
                if (bermudaExerciseNode.Attributes["href"] != null || bermudaExerciseNode.Attributes["id"] != null)
                {
                    if (bermudaExerciseNode.Attributes["id"] != null)
                    {
                        bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["id"].Value;
                        BermudaExercise ob = new BermudaExercise(bermudaExerciseNode);
                        IDManager.SetID(bermudaExerciseIDRef_, ob);
                    }
                    else if (bermudaExerciseNode.Attributes["href"] != null)
                    {
                        bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
                    }
                }
                else
                {
                    bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
                }
            }


            XmlNode europeanExerciseNode = xmlNode.SelectSingleNode("europeanExercise");

            if (europeanExerciseNode != null)
            {
                if (europeanExerciseNode.Attributes["href"] != null || europeanExerciseNode.Attributes["id"] != null)
                {
                    if (europeanExerciseNode.Attributes["id"] != null)
                    {
                        europeanExerciseIDRef_ = europeanExerciseNode.Attributes["id"].Value;
                        EuropeanExercise ob = new EuropeanExercise(europeanExerciseNode);
                        IDManager.SetID(europeanExerciseIDRef_, ob);
                    }
                    else if (europeanExerciseNode.Attributes["href"] != null)
                    {
                        europeanExerciseIDRef_ = europeanExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
                    }
                }
                else
                {
                    europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
                }
            }


            XmlNode exerciseProcedureNode = xmlNode.SelectSingleNode("exerciseProcedure");

            if (exerciseProcedureNode != null)
            {
                if (exerciseProcedureNode.Attributes["href"] != null || exerciseProcedureNode.Attributes["id"] != null)
                {
                    if (exerciseProcedureNode.Attributes["id"] != null)
                    {
                        exerciseProcedureIDRef_ = exerciseProcedureNode.Attributes["id"].Value;
                        ExerciseProcedure ob = new ExerciseProcedure(exerciseProcedureNode);
                        IDManager.SetID(exerciseProcedureIDRef_, ob);
                    }
                    else if (exerciseProcedureNode.Attributes["href"] != null)
                    {
                        exerciseProcedureIDRef_ = exerciseProcedureNode.Attributes["href"].Value;
                    }
                    else
                    {
                        exerciseProcedure_ = new ExerciseProcedure(exerciseProcedureNode);
                    }
                }
                else
                {
                    exerciseProcedure_ = new ExerciseProcedure(exerciseProcedureNode);
                }
            }


            XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");

            if (calculationAgentNode != null)
            {
                if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null)
                {
                    if (calculationAgentNode.Attributes["id"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                        CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                        IDManager.SetID(calculationAgentIDRef_, ob);
                    }
                    else if (calculationAgentNode.Attributes["href"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAgent_ = new CalculationAgent(calculationAgentNode);
                    }
                }
                else
                {
                    calculationAgent_ = new CalculationAgent(calculationAgentNode);
                }
            }


            XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");

            if (cashSettlementNode != null)
            {
                if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null)
                {
                    if (cashSettlementNode.Attributes["id"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                        CashSettlement ob = new CashSettlement(cashSettlementNode);
                        IDManager.SetID(cashSettlementIDRef_, ob);
                    }
                    else if (cashSettlementNode.Attributes["href"] != null)
                    {
                        cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashSettlement_ = new CashSettlement(cashSettlementNode);
                    }
                }
                else
                {
                    cashSettlement_ = new CashSettlement(cashSettlementNode);
                }
            }


            XmlNode physicalSettlementNode = xmlNode.SelectSingleNode("physicalSettlement");

            if (physicalSettlementNode != null)
            {
                if (physicalSettlementNode.Attributes["href"] != null || physicalSettlementNode.Attributes["id"] != null)
                {
                    if (physicalSettlementNode.Attributes["id"] != null)
                    {
                        physicalSettlementIDRef_ = physicalSettlementNode.Attributes["id"].Value;
                        SwaptionPhysicalSettlement ob = new SwaptionPhysicalSettlement(physicalSettlementNode);
                        IDManager.SetID(physicalSettlementIDRef_, ob);
                    }
                    else if (physicalSettlementNode.Attributes["href"] != null)
                    {
                        physicalSettlementIDRef_ = physicalSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        physicalSettlement_ = new SwaptionPhysicalSettlement(physicalSettlementNode);
                    }
                }
                else
                {
                    physicalSettlement_ = new SwaptionPhysicalSettlement(physicalSettlementNode);
                }
            }


            XmlNode swaptionStraddleNode = xmlNode.SelectSingleNode("swaptionStraddle");

            if (swaptionStraddleNode != null)
            {
                if (swaptionStraddleNode.Attributes["href"] != null || swaptionStraddleNode.Attributes["id"] != null)
                {
                    if (swaptionStraddleNode.Attributes["id"] != null)
                    {
                        swaptionStraddleIDRef_ = swaptionStraddleNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(swaptionStraddleNode);
                        IDManager.SetID(swaptionStraddleIDRef_, ob);
                    }
                    else if (swaptionStraddleNode.Attributes["href"] != null)
                    {
                        swaptionStraddleIDRef_ = swaptionStraddleNode.Attributes["href"].Value;
                    }
                    else
                    {
                        swaptionStraddle_ = new XsdTypeBoolean(swaptionStraddleNode);
                    }
                }
                else
                {
                    swaptionStraddle_ = new XsdTypeBoolean(swaptionStraddleNode);
                }
            }


            XmlNode swaptionAdjustedDatesNode = xmlNode.SelectSingleNode("swaptionAdjustedDates");

            if (swaptionAdjustedDatesNode != null)
            {
                if (swaptionAdjustedDatesNode.Attributes["href"] != null || swaptionAdjustedDatesNode.Attributes["id"] != null)
                {
                    if (swaptionAdjustedDatesNode.Attributes["id"] != null)
                    {
                        swaptionAdjustedDatesIDRef_ = swaptionAdjustedDatesNode.Attributes["id"].Value;
                        SwaptionAdjustedDates ob = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
                        IDManager.SetID(swaptionAdjustedDatesIDRef_, ob);
                    }
                    else if (swaptionAdjustedDatesNode.Attributes["href"] != null)
                    {
                        swaptionAdjustedDatesIDRef_ = swaptionAdjustedDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        swaptionAdjustedDates_ = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
                    }
                }
                else
                {
                    swaptionAdjustedDates_ = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
                }
            }


            XmlNode swapNode = xmlNode.SelectSingleNode("swap");

            if (swapNode != null)
            {
                if (swapNode.Attributes["href"] != null || swapNode.Attributes["id"] != null)
                {
                    if (swapNode.Attributes["id"] != null)
                    {
                        swapIDRef_ = swapNode.Attributes["id"].Value;
                        Swap ob = new Swap(swapNode);
                        IDManager.SetID(swapIDRef_, ob);
                    }
                    else if (swapNode.Attributes["href"] != null)
                    {
                        swapIDRef_ = swapNode.Attributes["href"].Value;
                    }
                    else
                    {
                        swap_ = new Swap(swapNode);
                    }
                }
                else
                {
                    swap_ = new Swap(swapNode);
                }
            }
        }
 public FallbackReferencePrice(XmlNode xmlNode)
 {
     XmlNodeList valuationPostponementNodeList = xmlNode.SelectNodes("valuationPostponement");
     if (valuationPostponementNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in valuationPostponementNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 valuationPostponementIDRef = item.Attributes["id"].Name;
                 ValuationPostponement ob = ValuationPostponement();
                 IDManager.SetID(valuationPostponementIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 valuationPostponementIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 valuationPostponement = new ValuationPostponement(item);
             }
         }
     }
     
 
     XmlNodeList fallbackSettlementRateOptionNodeList = xmlNode.SelectNodes("fallbackSettlementRateOption");
     
     foreach (XmlNode item in fallbackSettlementRateOptionNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fallbackSettlementRateOptionIDRef = item.Attributes["id"].Name;
                 List<SettlementRateOption> ob = new List<SettlementRateOption>();
                 ob.Add(new SettlementRateOption(item));
                 IDManager.SetID(fallbackSettlementRateOptionIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fallbackSettlementRateOptionIDRef = item.Attributes["href"].Name;
             }
             else
             {
             fallbackSettlementRateOption.Add(new SettlementRateOption(item));
             }
         }
     }
     
 
     XmlNodeList fallbackSurveyValuationPostponenmentNodeList = xmlNode.SelectNodes("fallbackSurveyValuationPostponenment");
     if (fallbackSurveyValuationPostponenmentNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in fallbackSurveyValuationPostponenmentNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 fallbackSurveyValuationPostponenmentIDRef = item.Attributes["id"].Name;
                 Empty ob = Empty();
                 IDManager.SetID(fallbackSurveyValuationPostponenmentIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 fallbackSurveyValuationPostponenmentIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 fallbackSurveyValuationPostponenment = new Empty(item);
             }
         }
     }
     
 
     XmlNodeList calculationAgentDeterminationNodeList = xmlNode.SelectNodes("calculationAgentDetermination");
     if (calculationAgentDeterminationNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in calculationAgentDeterminationNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 calculationAgentDeterminationIDRef = item.Attributes["id"].Name;
                 CalculationAgent ob = CalculationAgent();
                 IDManager.SetID(calculationAgentDeterminationIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 calculationAgentDeterminationIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 calculationAgentDetermination = new CalculationAgent(item);
             }
         }
     }
     
 
 }
 public FallbackReferencePrice(XmlNode xmlNode)
 {
     XmlNode valuationPostponementNode = xmlNode.SelectSingleNode("valuationPostponement");
     
     if (valuationPostponementNode != null)
     {
         if (valuationPostponementNode.Attributes["href"] != null || valuationPostponementNode.Attributes["id"] != null) 
         {
             if (valuationPostponementNode.Attributes["id"] != null) 
             {
                 valuationPostponementIDRef_ = valuationPostponementNode.Attributes["id"].Value;
                 ValuationPostponement ob = new ValuationPostponement(valuationPostponementNode);
                 IDManager.SetID(valuationPostponementIDRef_, ob);
             }
             else if (valuationPostponementNode.Attributes["href"] != null)
             {
                 valuationPostponementIDRef_ = valuationPostponementNode.Attributes["href"].Value;
             }
             else
             {
                 valuationPostponement_ = new ValuationPostponement(valuationPostponementNode);
             }
         }
         else
         {
             valuationPostponement_ = new ValuationPostponement(valuationPostponementNode);
         }
     }
     
 
     XmlNodeList fallbackSettlementRateOptionNodeList = xmlNode.SelectNodes("fallbackSettlementRateOption");
     
     if (fallbackSettlementRateOptionNodeList != null)
     {
         this.fallbackSettlementRateOption_ = new List<SettlementRateOption>();
         foreach (XmlNode item in fallbackSettlementRateOptionNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     fallbackSettlementRateOptionIDRef_ = item.Attributes["id"].Value;
                     fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
                     IDManager.SetID(fallbackSettlementRateOptionIDRef_, fallbackSettlementRateOption_[fallbackSettlementRateOption_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     fallbackSettlementRateOptionIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
                 }
             }
             else
             {
                 fallbackSettlementRateOption_.Add(new SettlementRateOption(item));
             }
         }
     }
     
 
     XmlNode fallbackSurveyValuationPostponenmentNode = xmlNode.SelectSingleNode("fallbackSurveyValuationPostponenment");
     
     if (fallbackSurveyValuationPostponenmentNode != null)
     {
         if (fallbackSurveyValuationPostponenmentNode.Attributes["href"] != null || fallbackSurveyValuationPostponenmentNode.Attributes["id"] != null) 
         {
             if (fallbackSurveyValuationPostponenmentNode.Attributes["id"] != null) 
             {
                 fallbackSurveyValuationPostponenmentIDRef_ = fallbackSurveyValuationPostponenmentNode.Attributes["id"].Value;
                 Empty ob = new Empty(fallbackSurveyValuationPostponenmentNode);
                 IDManager.SetID(fallbackSurveyValuationPostponenmentIDRef_, ob);
             }
             else if (fallbackSurveyValuationPostponenmentNode.Attributes["href"] != null)
             {
                 fallbackSurveyValuationPostponenmentIDRef_ = fallbackSurveyValuationPostponenmentNode.Attributes["href"].Value;
             }
             else
             {
                 fallbackSurveyValuationPostponenment_ = new Empty(fallbackSurveyValuationPostponenmentNode);
             }
         }
         else
         {
             fallbackSurveyValuationPostponenment_ = new Empty(fallbackSurveyValuationPostponenmentNode);
         }
     }
     
 
     XmlNode calculationAgentDeterminationNode = xmlNode.SelectSingleNode("calculationAgentDetermination");
     
     if (calculationAgentDeterminationNode != null)
     {
         if (calculationAgentDeterminationNode.Attributes["href"] != null || calculationAgentDeterminationNode.Attributes["id"] != null) 
         {
             if (calculationAgentDeterminationNode.Attributes["id"] != null) 
             {
                 calculationAgentDeterminationIDRef_ = calculationAgentDeterminationNode.Attributes["id"].Value;
                 CalculationAgent ob = new CalculationAgent(calculationAgentDeterminationNode);
                 IDManager.SetID(calculationAgentDeterminationIDRef_, ob);
             }
             else if (calculationAgentDeterminationNode.Attributes["href"] != null)
             {
                 calculationAgentDeterminationIDRef_ = calculationAgentDeterminationNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgentDetermination_ = new CalculationAgent(calculationAgentDeterminationNode);
             }
         }
         else
         {
             calculationAgentDetermination_ = new CalculationAgent(calculationAgentDeterminationNode);
         }
     }
     
 
 }
 public Swaption(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode buyerPartyReferenceNode = xmlNode.SelectSingleNode("buyerPartyReference");
     
     if (buyerPartyReferenceNode != null)
     {
         if (buyerPartyReferenceNode.Attributes["href"] != null || buyerPartyReferenceNode.Attributes["id"] != null) 
         {
             if (buyerPartyReferenceNode.Attributes["id"] != null) 
             {
                 buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["id"].Value;
                 PartyReference ob = new PartyReference(buyerPartyReferenceNode);
                 IDManager.SetID(buyerPartyReferenceIDRef_, ob);
             }
             else if (buyerPartyReferenceNode.Attributes["href"] != null)
             {
                 buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
             }
         }
         else
         {
             buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
         }
     }
     
 
     XmlNode buyerAccountReferenceNode = xmlNode.SelectSingleNode("buyerAccountReference");
     
     if (buyerAccountReferenceNode != null)
     {
         if (buyerAccountReferenceNode.Attributes["href"] != null || buyerAccountReferenceNode.Attributes["id"] != null) 
         {
             if (buyerAccountReferenceNode.Attributes["id"] != null) 
             {
                 buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["id"].Value;
                 AccountReference ob = new AccountReference(buyerAccountReferenceNode);
                 IDManager.SetID(buyerAccountReferenceIDRef_, ob);
             }
             else if (buyerAccountReferenceNode.Attributes["href"] != null)
             {
                 buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
             }
         }
         else
         {
             buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
         }
     }
     
 
     XmlNode sellerPartyReferenceNode = xmlNode.SelectSingleNode("sellerPartyReference");
     
     if (sellerPartyReferenceNode != null)
     {
         if (sellerPartyReferenceNode.Attributes["href"] != null || sellerPartyReferenceNode.Attributes["id"] != null) 
         {
             if (sellerPartyReferenceNode.Attributes["id"] != null) 
             {
                 sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["id"].Value;
                 PartyReference ob = new PartyReference(sellerPartyReferenceNode);
                 IDManager.SetID(sellerPartyReferenceIDRef_, ob);
             }
             else if (sellerPartyReferenceNode.Attributes["href"] != null)
             {
                 sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
             }
         }
         else
         {
             sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
         }
     }
     
 
     XmlNode sellerAccountReferenceNode = xmlNode.SelectSingleNode("sellerAccountReference");
     
     if (sellerAccountReferenceNode != null)
     {
         if (sellerAccountReferenceNode.Attributes["href"] != null || sellerAccountReferenceNode.Attributes["id"] != null) 
         {
             if (sellerAccountReferenceNode.Attributes["id"] != null) 
             {
                 sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["id"].Value;
                 AccountReference ob = new AccountReference(sellerAccountReferenceNode);
                 IDManager.SetID(sellerAccountReferenceIDRef_, ob);
             }
             else if (sellerAccountReferenceNode.Attributes["href"] != null)
             {
                 sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
             }
         }
         else
         {
             sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
         }
     }
     
 
     XmlNodeList premiumNodeList = xmlNode.SelectNodes("premium");
     
     if (premiumNodeList != null)
     {
         this.premium_ = new List<Payment>();
         foreach (XmlNode item in premiumNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     premiumIDRef_ = item.Attributes["id"].Value;
                     premium_.Add(new Payment(item));
                     IDManager.SetID(premiumIDRef_, premium_[premium_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     premiumIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 premium_.Add(new Payment(item));
                 }
             }
             else
             {
                 premium_.Add(new Payment(item));
             }
         }
     }
     
 
     XmlNode exerciseNode = xmlNode.SelectSingleNode("exercise");
     
     if (exerciseNode != null)
     {
         if (exerciseNode.Attributes["href"] != null || exerciseNode.Attributes["id"] != null) 
         {
             if (exerciseNode.Attributes["id"] != null) 
             {
                 exerciseIDRef_ = exerciseNode.Attributes["id"].Value;
                 Exercise ob = new Exercise(exerciseNode);
                 IDManager.SetID(exerciseIDRef_, ob);
             }
             else if (exerciseNode.Attributes["href"] != null)
             {
                 exerciseIDRef_ = exerciseNode.Attributes["href"].Value;
             }
             else
             {
                 exercise_ = new Exercise(exerciseNode);
             }
         }
         else
         {
             exercise_ = new Exercise(exerciseNode);
         }
     }
     
 
     XmlNode americanExerciseNode = xmlNode.SelectSingleNode("americanExercise");
     
     if (americanExerciseNode != null)
     {
         if (americanExerciseNode.Attributes["href"] != null || americanExerciseNode.Attributes["id"] != null) 
         {
             if (americanExerciseNode.Attributes["id"] != null) 
             {
                 americanExerciseIDRef_ = americanExerciseNode.Attributes["id"].Value;
                 AmericanExercise ob = new AmericanExercise(americanExerciseNode);
                 IDManager.SetID(americanExerciseIDRef_, ob);
             }
             else if (americanExerciseNode.Attributes["href"] != null)
             {
                 americanExerciseIDRef_ = americanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 americanExercise_ = new AmericanExercise(americanExerciseNode);
             }
         }
         else
         {
             americanExercise_ = new AmericanExercise(americanExerciseNode);
         }
     }
     
 
     XmlNode bermudaExerciseNode = xmlNode.SelectSingleNode("bermudaExercise");
     
     if (bermudaExerciseNode != null)
     {
         if (bermudaExerciseNode.Attributes["href"] != null || bermudaExerciseNode.Attributes["id"] != null) 
         {
             if (bermudaExerciseNode.Attributes["id"] != null) 
             {
                 bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["id"].Value;
                 BermudaExercise ob = new BermudaExercise(bermudaExerciseNode);
                 IDManager.SetID(bermudaExerciseIDRef_, ob);
             }
             else if (bermudaExerciseNode.Attributes["href"] != null)
             {
                 bermudaExerciseIDRef_ = bermudaExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
             }
         }
         else
         {
             bermudaExercise_ = new BermudaExercise(bermudaExerciseNode);
         }
     }
     
 
     XmlNode europeanExerciseNode = xmlNode.SelectSingleNode("europeanExercise");
     
     if (europeanExerciseNode != null)
     {
         if (europeanExerciseNode.Attributes["href"] != null || europeanExerciseNode.Attributes["id"] != null) 
         {
             if (europeanExerciseNode.Attributes["id"] != null) 
             {
                 europeanExerciseIDRef_ = europeanExerciseNode.Attributes["id"].Value;
                 EuropeanExercise ob = new EuropeanExercise(europeanExerciseNode);
                 IDManager.SetID(europeanExerciseIDRef_, ob);
             }
             else if (europeanExerciseNode.Attributes["href"] != null)
             {
                 europeanExerciseIDRef_ = europeanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
             }
         }
         else
         {
             europeanExercise_ = new EuropeanExercise(europeanExerciseNode);
         }
     }
     
 
     XmlNode exerciseProcedureNode = xmlNode.SelectSingleNode("exerciseProcedure");
     
     if (exerciseProcedureNode != null)
     {
         if (exerciseProcedureNode.Attributes["href"] != null || exerciseProcedureNode.Attributes["id"] != null) 
         {
             if (exerciseProcedureNode.Attributes["id"] != null) 
             {
                 exerciseProcedureIDRef_ = exerciseProcedureNode.Attributes["id"].Value;
                 ExerciseProcedure ob = new ExerciseProcedure(exerciseProcedureNode);
                 IDManager.SetID(exerciseProcedureIDRef_, ob);
             }
             else if (exerciseProcedureNode.Attributes["href"] != null)
             {
                 exerciseProcedureIDRef_ = exerciseProcedureNode.Attributes["href"].Value;
             }
             else
             {
                 exerciseProcedure_ = new ExerciseProcedure(exerciseProcedureNode);
             }
         }
         else
         {
             exerciseProcedure_ = new ExerciseProcedure(exerciseProcedureNode);
         }
     }
     
 
     XmlNode calculationAgentNode = xmlNode.SelectSingleNode("calculationAgent");
     
     if (calculationAgentNode != null)
     {
         if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null) 
         {
             if (calculationAgentNode.Attributes["id"] != null) 
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                 CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                 IDManager.SetID(calculationAgentIDRef_, ob);
             }
             else if (calculationAgentNode.Attributes["href"] != null)
             {
                 calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
             }
             else
             {
                 calculationAgent_ = new CalculationAgent(calculationAgentNode);
             }
         }
         else
         {
             calculationAgent_ = new CalculationAgent(calculationAgentNode);
         }
     }
     
 
     XmlNode cashSettlementNode = xmlNode.SelectSingleNode("cashSettlement");
     
     if (cashSettlementNode != null)
     {
         if (cashSettlementNode.Attributes["href"] != null || cashSettlementNode.Attributes["id"] != null) 
         {
             if (cashSettlementNode.Attributes["id"] != null) 
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["id"].Value;
                 CashSettlement ob = new CashSettlement(cashSettlementNode);
                 IDManager.SetID(cashSettlementIDRef_, ob);
             }
             else if (cashSettlementNode.Attributes["href"] != null)
             {
                 cashSettlementIDRef_ = cashSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 cashSettlement_ = new CashSettlement(cashSettlementNode);
             }
         }
         else
         {
             cashSettlement_ = new CashSettlement(cashSettlementNode);
         }
     }
     
 
     XmlNode physicalSettlementNode = xmlNode.SelectSingleNode("physicalSettlement");
     
     if (physicalSettlementNode != null)
     {
         if (physicalSettlementNode.Attributes["href"] != null || physicalSettlementNode.Attributes["id"] != null) 
         {
             if (physicalSettlementNode.Attributes["id"] != null) 
             {
                 physicalSettlementIDRef_ = physicalSettlementNode.Attributes["id"].Value;
                 SwaptionPhysicalSettlement ob = new SwaptionPhysicalSettlement(physicalSettlementNode);
                 IDManager.SetID(physicalSettlementIDRef_, ob);
             }
             else if (physicalSettlementNode.Attributes["href"] != null)
             {
                 physicalSettlementIDRef_ = physicalSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 physicalSettlement_ = new SwaptionPhysicalSettlement(physicalSettlementNode);
             }
         }
         else
         {
             physicalSettlement_ = new SwaptionPhysicalSettlement(physicalSettlementNode);
         }
     }
     
 
     XmlNode swaptionStraddleNode = xmlNode.SelectSingleNode("swaptionStraddle");
     
     if (swaptionStraddleNode != null)
     {
         if (swaptionStraddleNode.Attributes["href"] != null || swaptionStraddleNode.Attributes["id"] != null) 
         {
             if (swaptionStraddleNode.Attributes["id"] != null) 
             {
                 swaptionStraddleIDRef_ = swaptionStraddleNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(swaptionStraddleNode);
                 IDManager.SetID(swaptionStraddleIDRef_, ob);
             }
             else if (swaptionStraddleNode.Attributes["href"] != null)
             {
                 swaptionStraddleIDRef_ = swaptionStraddleNode.Attributes["href"].Value;
             }
             else
             {
                 swaptionStraddle_ = new XsdTypeBoolean(swaptionStraddleNode);
             }
         }
         else
         {
             swaptionStraddle_ = new XsdTypeBoolean(swaptionStraddleNode);
         }
     }
     
 
     XmlNode swaptionAdjustedDatesNode = xmlNode.SelectSingleNode("swaptionAdjustedDates");
     
     if (swaptionAdjustedDatesNode != null)
     {
         if (swaptionAdjustedDatesNode.Attributes["href"] != null || swaptionAdjustedDatesNode.Attributes["id"] != null) 
         {
             if (swaptionAdjustedDatesNode.Attributes["id"] != null) 
             {
                 swaptionAdjustedDatesIDRef_ = swaptionAdjustedDatesNode.Attributes["id"].Value;
                 SwaptionAdjustedDates ob = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
                 IDManager.SetID(swaptionAdjustedDatesIDRef_, ob);
             }
             else if (swaptionAdjustedDatesNode.Attributes["href"] != null)
             {
                 swaptionAdjustedDatesIDRef_ = swaptionAdjustedDatesNode.Attributes["href"].Value;
             }
             else
             {
                 swaptionAdjustedDates_ = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
             }
         }
         else
         {
             swaptionAdjustedDates_ = new SwaptionAdjustedDates(swaptionAdjustedDatesNode);
         }
     }
     
 
     XmlNode swapNode = xmlNode.SelectSingleNode("swap");
     
     if (swapNode != null)
     {
         if (swapNode.Attributes["href"] != null || swapNode.Attributes["id"] != null) 
         {
             if (swapNode.Attributes["id"] != null) 
             {
                 swapIDRef_ = swapNode.Attributes["id"].Value;
                 Swap ob = new Swap(swapNode);
                 IDManager.SetID(swapIDRef_, ob);
             }
             else if (swapNode.Attributes["href"] != null)
             {
                 swapIDRef_ = swapNode.Attributes["href"].Value;
             }
             else
             {
                 swap_ = new Swap(swapNode);
             }
         }
         else
         {
             swap_ = new Swap(swapNode);
         }
     }
     
 
 }