public ReportIdentification(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList numberOfSectionsNodeList = xmlNode.SelectNodes("numberOfSections");

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

            foreach (XmlNode item in numberOfSectionsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        numberOfSectionsIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(numberOfSectionsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        numberOfSectionsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        numberOfSections = new XsdTypePositiveInteger(item);
                    }
                }
            }


            XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");

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

            foreach (XmlNode item in submissionsCompleteNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        submissionsCompleteIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(submissionsCompleteIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        submissionsCompleteIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        submissionsComplete = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 2
0
        public SwaptionPhysicalSettlement(XmlNode xmlNode)
        {
            XmlNodeList clearedPhysicalSettlementNodeList = xmlNode.SelectNodes("clearedPhysicalSettlement");

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

            foreach (XmlNode item in clearedPhysicalSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        clearedPhysicalSettlementIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(clearedPhysicalSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        clearedPhysicalSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        clearedPhysicalSettlement = new XsdTypeBoolean(item);
                    }
                }
            }
        }
 public ReportIdentification(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode numberOfSectionsNode = xmlNode.SelectSingleNode("numberOfSections");
     
     if (numberOfSectionsNode != null)
     {
         if (numberOfSectionsNode.Attributes["href"] != null || numberOfSectionsNode.Attributes["id"] != null) 
         {
             if (numberOfSectionsNode.Attributes["id"] != null) 
             {
                 numberOfSectionsIDRef_ = numberOfSectionsNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberOfSectionsNode);
                 IDManager.SetID(numberOfSectionsIDRef_, ob);
             }
             else if (numberOfSectionsNode.Attributes["href"] != null)
             {
                 numberOfSectionsIDRef_ = numberOfSectionsNode.Attributes["href"].Value;
             }
             else
             {
                 numberOfSections_ = new XsdTypePositiveInteger(numberOfSectionsNode);
             }
         }
         else
         {
             numberOfSections_ = new XsdTypePositiveInteger(numberOfSectionsNode);
         }
     }
     
 
     XmlNode submissionsCompleteNode = xmlNode.SelectSingleNode("submissionsComplete");
     
     if (submissionsCompleteNode != null)
     {
         if (submissionsCompleteNode.Attributes["href"] != null || submissionsCompleteNode.Attributes["id"] != null) 
         {
             if (submissionsCompleteNode.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(submissionsCompleteNode);
                 IDManager.SetID(submissionsCompleteIDRef_, ob);
             }
             else if (submissionsCompleteNode.Attributes["href"] != null)
             {
                 submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["href"].Value;
             }
             else
             {
                 submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
             }
         }
         else
         {
             submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
         }
     }
     
 
 }
        public CommodityCalculationPeriodsSchedule(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList balanceOfFirstPeriodNodeList = xmlNode.SelectNodes("balanceOfFirstPeriod");

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

            foreach (XmlNode item in balanceOfFirstPeriodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        balanceOfFirstPeriodIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(balanceOfFirstPeriodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        balanceOfFirstPeriodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        balanceOfFirstPeriod = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 5
0
        public ElectricityDeliveryFirm(XmlNode xmlNode)
        {
            XmlNodeList forceMajeureNodeList = xmlNode.SelectNodes("forceMajeure");

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

            foreach (XmlNode item in forceMajeureNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        forceMajeureIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(forceMajeureIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        forceMajeureIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        forceMajeure = new XsdTypeBoolean(item);
                    }
                }
            }
        }
        public SingeSimpleCal(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode pastOccNode = xmlNode.SelectSingleNode("pastOcc");

            if (pastOccNode != null)
            {
                if (pastOccNode.Attributes["href"] != null || pastOccNode.Attributes["id"] != null)
                {
                    if (pastOccNode.Attributes["id"] != null)
                    {
                        pastOccIDRef_ = pastOccNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(pastOccNode);
                        IDManager.SetID(pastOccIDRef_, ob);
                    }
                    else if (pastOccNode.Attributes["href"] != null)
                    {
                        pastOccIDRef_ = pastOccNode.Attributes["href"].Value;
                    }
                    else
                    {
                        pastOcc_ = new XsdTypeBoolean(pastOccNode);
                    }
                }
                else
                {
                    pastOcc_ = new XsdTypeBoolean(pastOccNode);
                }
            }
        }
        public MutualFund(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList openEndedFundNodeList = xmlNode.SelectNodes("openEndedFund");

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

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


            XmlNodeList fundManagerNodeList = xmlNode.SelectNodes("fundManager");

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

            foreach (XmlNode item in fundManagerNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fundManagerIDRef = item.Attributes["id"].Name;
                        XsdTypeString ob = XsdTypeString();
                        IDManager.SetID(fundManagerIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fundManagerIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fundManager = new XsdTypeString(item);
                    }
                }
            }
        }
 public AndSimpleCal(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode pastOccNode = xmlNode.SelectSingleNode("pastOcc");
     
     if (pastOccNode != null)
     {
         if (pastOccNode.Attributes["href"] != null || pastOccNode.Attributes["id"] != null) 
         {
             if (pastOccNode.Attributes["id"] != null) 
             {
                 pastOccIDRef_ = pastOccNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(pastOccNode);
                 IDManager.SetID(pastOccIDRef_, ob);
             }
             else if (pastOccNode.Attributes["href"] != null)
             {
                 pastOccIDRef_ = pastOccNode.Attributes["href"].Value;
             }
             else
             {
                 pastOcc_ = new XsdTypeBoolean(pastOccNode);
             }
         }
         else
         {
             pastOcc_ = new XsdTypeBoolean(pastOccNode);
         }
     }
     
 
 }
 public ElectricityDeliveryFirm(XmlNode xmlNode)
 {
     XmlNode forceMajeureNode = xmlNode.SelectSingleNode("forceMajeure");
     
     if (forceMajeureNode != null)
     {
         if (forceMajeureNode.Attributes["href"] != null || forceMajeureNode.Attributes["id"] != null) 
         {
             if (forceMajeureNode.Attributes["id"] != null) 
             {
                 forceMajeureIDRef_ = forceMajeureNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(forceMajeureNode);
                 IDManager.SetID(forceMajeureIDRef_, ob);
             }
             else if (forceMajeureNode.Attributes["href"] != null)
             {
                 forceMajeureIDRef_ = forceMajeureNode.Attributes["href"].Value;
             }
             else
             {
                 forceMajeure_ = new XsdTypeBoolean(forceMajeureNode);
             }
         }
         else
         {
             forceMajeure_ = new XsdTypeBoolean(forceMajeureNode);
         }
     }
     
 
 }
        public ElectricityDeliveryFirm(XmlNode xmlNode)
        {
            XmlNode forceMajeureNode = xmlNode.SelectSingleNode("forceMajeure");

            if (forceMajeureNode != null)
            {
                if (forceMajeureNode.Attributes["href"] != null || forceMajeureNode.Attributes["id"] != null)
                {
                    if (forceMajeureNode.Attributes["id"] != null)
                    {
                        forceMajeureIDRef_ = forceMajeureNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(forceMajeureNode);
                        IDManager.SetID(forceMajeureIDRef_, ob);
                    }
                    else if (forceMajeureNode.Attributes["href"] != null)
                    {
                        forceMajeureIDRef_ = forceMajeureNode.Attributes["href"].Value;
                    }
                    else
                    {
                        forceMajeure_ = new XsdTypeBoolean(forceMajeureNode);
                    }
                }
                else
                {
                    forceMajeure_ = new XsdTypeBoolean(forceMajeureNode);
                }
            }
        }
 public OrEventCal(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode eventCalculationListNode = xmlNode.SelectSingleNode("eventCalculationList");
     
     if (eventCalculationListNode != null)
     {
         if (eventCalculationListNode.Attributes["href"] != null || eventCalculationListNode.Attributes["id"] != null) 
         {
             if (eventCalculationListNode.Attributes["id"] != null) 
             {
                 eventCalculationListIDRef_ = eventCalculationListNode.Attributes["id"].Value;
                 EventCalculationList ob = new EventCalculationList(eventCalculationListNode);
                 IDManager.SetID(eventCalculationListIDRef_, ob);
             }
             else if (eventCalculationListNode.Attributes["href"] != null)
             {
                 eventCalculationListIDRef_ = eventCalculationListNode.Attributes["href"].Value;
             }
             else
             {
                 eventCalculationList_ = new EventCalculationList(eventCalculationListNode);
             }
         }
         else
         {
             eventCalculationList_ = new EventCalculationList(eventCalculationListNode);
         }
     }
     
 
     XmlNode complementNode = xmlNode.SelectSingleNode("complement");
     
     if (complementNode != null)
     {
         if (complementNode.Attributes["href"] != null || complementNode.Attributes["id"] != null) 
         {
             if (complementNode.Attributes["id"] != null) 
             {
                 complementIDRef_ = complementNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(complementNode);
                 IDManager.SetID(complementIDRef_, ob);
             }
             else if (complementNode.Attributes["href"] != null)
             {
                 complementIDRef_ = complementNode.Attributes["href"].Value;
             }
             else
             {
                 complement_ = new XsdTypeBoolean(complementNode);
             }
         }
         else
         {
             complement_ = new XsdTypeBoolean(complementNode);
         }
     }
     
 
 }
Ejemplo n.º 12
0
 public SwaptionPhysicalSettlement(XmlNode xmlNode)
 {
     XmlNode clearedPhysicalSettlementNode = xmlNode.SelectSingleNode("clearedPhysicalSettlement");
     
     if (clearedPhysicalSettlementNode != null)
     {
         if (clearedPhysicalSettlementNode.Attributes["href"] != null || clearedPhysicalSettlementNode.Attributes["id"] != null) 
         {
             if (clearedPhysicalSettlementNode.Attributes["id"] != null) 
             {
                 clearedPhysicalSettlementIDRef_ = clearedPhysicalSettlementNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(clearedPhysicalSettlementNode);
                 IDManager.SetID(clearedPhysicalSettlementIDRef_, ob);
             }
             else if (clearedPhysicalSettlementNode.Attributes["href"] != null)
             {
                 clearedPhysicalSettlementIDRef_ = clearedPhysicalSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 clearedPhysicalSettlement_ = new XsdTypeBoolean(clearedPhysicalSettlementNode);
             }
         }
         else
         {
             clearedPhysicalSettlement_ = new XsdTypeBoolean(clearedPhysicalSettlementNode);
         }
     }
     
 
 }
 public MutualFund(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode openEndedFundNode = xmlNode.SelectSingleNode("openEndedFund");
     
     if (openEndedFundNode != null)
     {
         if (openEndedFundNode.Attributes["href"] != null || openEndedFundNode.Attributes["id"] != null) 
         {
             if (openEndedFundNode.Attributes["id"] != null) 
             {
                 openEndedFundIDRef_ = openEndedFundNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(openEndedFundNode);
                 IDManager.SetID(openEndedFundIDRef_, ob);
             }
             else if (openEndedFundNode.Attributes["href"] != null)
             {
                 openEndedFundIDRef_ = openEndedFundNode.Attributes["href"].Value;
             }
             else
             {
                 openEndedFund_ = new XsdTypeBoolean(openEndedFundNode);
             }
         }
         else
         {
             openEndedFund_ = new XsdTypeBoolean(openEndedFundNode);
         }
     }
     
 
     XmlNode fundManagerNode = xmlNode.SelectSingleNode("fundManager");
     
     if (fundManagerNode != null)
     {
         if (fundManagerNode.Attributes["href"] != null || fundManagerNode.Attributes["id"] != null) 
         {
             if (fundManagerNode.Attributes["id"] != null) 
             {
                 fundManagerIDRef_ = fundManagerNode.Attributes["id"].Value;
                 XsdTypeString ob = new XsdTypeString(fundManagerNode);
                 IDManager.SetID(fundManagerIDRef_, ob);
             }
             else if (fundManagerNode.Attributes["href"] != null)
             {
                 fundManagerIDRef_ = fundManagerNode.Attributes["href"].Value;
             }
             else
             {
                 fundManager_ = new XsdTypeString(fundManagerNode);
             }
         }
         else
         {
             fundManager_ = new XsdTypeString(fundManagerNode);
         }
     }
     
 
 }
Ejemplo n.º 14
0
        public CommodityCalculationPeriodsSchedule(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode balanceOfFirstPeriodNode = xmlNode.SelectSingleNode("balanceOfFirstPeriod");

            if (balanceOfFirstPeriodNode != null)
            {
                if (balanceOfFirstPeriodNode.Attributes["href"] != null || balanceOfFirstPeriodNode.Attributes["id"] != null)
                {
                    if (balanceOfFirstPeriodNode.Attributes["id"] != null)
                    {
                        balanceOfFirstPeriodIDRef_ = balanceOfFirstPeriodNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(balanceOfFirstPeriodNode);
                        IDManager.SetID(balanceOfFirstPeriodIDRef_, ob);
                    }
                    else if (balanceOfFirstPeriodNode.Attributes["href"] != null)
                    {
                        balanceOfFirstPeriodIDRef_ = balanceOfFirstPeriodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        balanceOfFirstPeriod_ = new XsdTypeBoolean(balanceOfFirstPeriodNode);
                    }
                }
                else
                {
                    balanceOfFirstPeriod_ = new XsdTypeBoolean(balanceOfFirstPeriodNode);
                }
            }
        }
 public PortfolioReference(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode sequenceNumberNode = xmlNode.SelectSingleNode("sequenceNumber");
     
     if (sequenceNumberNode != null)
     {
         if (sequenceNumberNode.Attributes["href"] != null || sequenceNumberNode.Attributes["id"] != null) 
         {
             if (sequenceNumberNode.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef_ = sequenceNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sequenceNumberNode);
                 IDManager.SetID(sequenceNumberIDRef_, ob);
             }
             else if (sequenceNumberNode.Attributes["href"] != null)
             {
                 sequenceNumberIDRef_ = sequenceNumberNode.Attributes["href"].Value;
             }
             else
             {
                 sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
             }
         }
         else
         {
             sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
         }
     }
     
 
     XmlNode submissionsCompleteNode = xmlNode.SelectSingleNode("submissionsComplete");
     
     if (submissionsCompleteNode != null)
     {
         if (submissionsCompleteNode.Attributes["href"] != null || submissionsCompleteNode.Attributes["id"] != null) 
         {
             if (submissionsCompleteNode.Attributes["id"] != null) 
             {
                 submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(submissionsCompleteNode);
                 IDManager.SetID(submissionsCompleteIDRef_, ob);
             }
             else if (submissionsCompleteNode.Attributes["href"] != null)
             {
                 submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["href"].Value;
             }
             else
             {
                 submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
             }
         }
         else
         {
             submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
         }
     }
     
 
 }
 public CommodityCalculationPeriodsSchedule(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode balanceOfFirstPeriodNode = xmlNode.SelectSingleNode("balanceOfFirstPeriod");
     
     if (balanceOfFirstPeriodNode != null)
     {
         if (balanceOfFirstPeriodNode.Attributes["href"] != null || balanceOfFirstPeriodNode.Attributes["id"] != null) 
         {
             if (balanceOfFirstPeriodNode.Attributes["id"] != null) 
             {
                 balanceOfFirstPeriodIDRef_ = balanceOfFirstPeriodNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(balanceOfFirstPeriodNode);
                 IDManager.SetID(balanceOfFirstPeriodIDRef_, ob);
             }
             else if (balanceOfFirstPeriodNode.Attributes["href"] != null)
             {
                 balanceOfFirstPeriodIDRef_ = balanceOfFirstPeriodNode.Attributes["href"].Value;
             }
             else
             {
                 balanceOfFirstPeriod_ = new XsdTypeBoolean(balanceOfFirstPeriodNode);
             }
         }
         else
         {
             balanceOfFirstPeriod_ = new XsdTypeBoolean(balanceOfFirstPeriodNode);
         }
     }
     
 
 }
Ejemplo n.º 17
0
        public PortfolioReference(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");

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

            foreach (XmlNode item in sequenceNumberNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        sequenceNumberIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(sequenceNumberIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        sequenceNumberIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        sequenceNumber = new XsdTypePositiveInteger(item);
                    }
                }
            }


            XmlNodeList submissionsCompleteNodeList = xmlNode.SelectNodes("submissionsComplete");

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

            foreach (XmlNode item in submissionsCompleteNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        submissionsCompleteIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(submissionsCompleteIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        submissionsCompleteIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        submissionsComplete = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 18
0
        public GracePeriodExtension(XmlNode xmlNode)
        {
            XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");

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

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


            XmlNodeList gracePeriodNodeList = xmlNode.SelectNodes("gracePeriod");

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

            foreach (XmlNode item in gracePeriodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        gracePeriodIDRef = item.Attributes["id"].Name;
                        Offset ob = Offset();
                        IDManager.SetID(gracePeriodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        gracePeriodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        gracePeriod = new Offset(item);
                    }
                }
            }
        }
 public ElectricityDeliveryUnitFirm(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode generationAssetNode = xmlNode.SelectSingleNode("generationAsset");
     
     if (generationAssetNode != null)
     {
         if (generationAssetNode.Attributes["href"] != null || generationAssetNode.Attributes["id"] != null) 
         {
             if (generationAssetNode.Attributes["id"] != null) 
             {
                 generationAssetIDRef_ = generationAssetNode.Attributes["id"].Value;
                 CommodityDeliveryPoint ob = new CommodityDeliveryPoint(generationAssetNode);
                 IDManager.SetID(generationAssetIDRef_, ob);
             }
             else if (generationAssetNode.Attributes["href"] != null)
             {
                 generationAssetIDRef_ = generationAssetNode.Attributes["href"].Value;
             }
             else
             {
                 generationAsset_ = new CommodityDeliveryPoint(generationAssetNode);
             }
         }
         else
         {
             generationAsset_ = new CommodityDeliveryPoint(generationAssetNode);
         }
     }
     
 
 }
 public OilTransferDelivery(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode deliveryLocationNode = xmlNode.SelectSingleNode("deliveryLocation");
     
     if (deliveryLocationNode != null)
     {
         if (deliveryLocationNode.Attributes["href"] != null || deliveryLocationNode.Attributes["id"] != null) 
         {
             if (deliveryLocationNode.Attributes["id"] != null) 
             {
                 deliveryLocationIDRef_ = deliveryLocationNode.Attributes["id"].Value;
                 CommodityDeliveryPoint ob = new CommodityDeliveryPoint(deliveryLocationNode);
                 IDManager.SetID(deliveryLocationIDRef_, ob);
             }
             else if (deliveryLocationNode.Attributes["href"] != null)
             {
                 deliveryLocationIDRef_ = deliveryLocationNode.Attributes["href"].Value;
             }
             else
             {
                 deliveryLocation_ = new CommodityDeliveryPoint(deliveryLocationNode);
             }
         }
         else
         {
             deliveryLocation_ = new CommodityDeliveryPoint(deliveryLocationNode);
         }
     }
     
 
 }
 public GracePeriodExtension(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode gracePeriodNode = xmlNode.SelectSingleNode("gracePeriod");
     
     if (gracePeriodNode != null)
     {
         if (gracePeriodNode.Attributes["href"] != null || gracePeriodNode.Attributes["id"] != null) 
         {
             if (gracePeriodNode.Attributes["id"] != null) 
             {
                 gracePeriodIDRef_ = gracePeriodNode.Attributes["id"].Value;
                 Offset ob = new Offset(gracePeriodNode);
                 IDManager.SetID(gracePeriodIDRef_, ob);
             }
             else if (gracePeriodNode.Attributes["href"] != null)
             {
                 gracePeriodIDRef_ = gracePeriodNode.Attributes["href"].Value;
             }
             else
             {
                 gracePeriod_ = new Offset(gracePeriodNode);
             }
         }
         else
         {
             gracePeriod_ = new Offset(gracePeriodNode);
         }
     }
     
 
 }
 public PCDeliverableObligationCharac(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode partialCashSettlementNode = xmlNode.SelectSingleNode("partialCashSettlement");
     
     if (partialCashSettlementNode != null)
     {
         if (partialCashSettlementNode.Attributes["href"] != null || partialCashSettlementNode.Attributes["id"] != null) 
         {
             if (partialCashSettlementNode.Attributes["id"] != null) 
             {
                 partialCashSettlementIDRef_ = partialCashSettlementNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(partialCashSettlementNode);
                 IDManager.SetID(partialCashSettlementIDRef_, ob);
             }
             else if (partialCashSettlementNode.Attributes["href"] != null)
             {
                 partialCashSettlementIDRef_ = partialCashSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 partialCashSettlement_ = new XsdTypeBoolean(partialCashSettlementNode);
             }
         }
         else
         {
             partialCashSettlement_ = new XsdTypeBoolean(partialCashSettlementNode);
         }
     }
     
 
 }
Ejemplo n.º 23
0
        public ElectricityDeliverySystemFirm(XmlNode xmlNode)
        {
            XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");

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

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


            XmlNodeList systemNodeList = xmlNode.SelectNodes("system");

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

            foreach (XmlNode item in systemNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        systemIDRef = item.Attributes["id"].Name;
                        CommodityDeliveryPoint ob = CommodityDeliveryPoint();
                        IDManager.SetID(systemIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        systemIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        system = new CommodityDeliveryPoint(item);
                    }
                }
            }
        }
 public Function(XmlNode xmlNode)
 {
     XmlNode nameNode = xmlNode.SelectSingleNode("name");
     
     if (nameNode != null)
     {
         if (nameNode.Attributes["href"] != null || nameNode.Attributes["id"] != null) 
         {
             if (nameNode.Attributes["id"] != null) 
             {
                 nameIDRef_ = nameNode.Attributes["id"].Value;
                 XsdTypeToken ob = new XsdTypeToken(nameNode);
                 IDManager.SetID(nameIDRef_, ob);
             }
             else if (nameNode.Attributes["href"] != null)
             {
                 nameIDRef_ = nameNode.Attributes["href"].Value;
             }
             else
             {
                 name_ = new XsdTypeToken(nameNode);
             }
         }
         else
         {
             name_ = new XsdTypeToken(nameNode);
         }
     }
     
 
     XmlNode truefalseNode = xmlNode.SelectSingleNode("truefalse");
     
     if (truefalseNode != null)
     {
         if (truefalseNode.Attributes["href"] != null || truefalseNode.Attributes["id"] != null) 
         {
             if (truefalseNode.Attributes["id"] != null) 
             {
                 truefalseIDRef_ = truefalseNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(truefalseNode);
                 IDManager.SetID(truefalseIDRef_, ob);
             }
             else if (truefalseNode.Attributes["href"] != null)
             {
                 truefalseIDRef_ = truefalseNode.Attributes["href"].Value;
             }
             else
             {
                 truefalse_ = new XsdTypeBoolean(truefalseNode);
             }
         }
         else
         {
             truefalse_ = new XsdTypeBoolean(truefalseNode);
         }
     }
     
 
 }
 public ManualExercise(XmlNode xmlNode)
 {
     XmlNode exerciseNoticeNode = xmlNode.SelectSingleNode("exerciseNotice");
     
     if (exerciseNoticeNode != null)
     {
         if (exerciseNoticeNode.Attributes["href"] != null || exerciseNoticeNode.Attributes["id"] != null) 
         {
             if (exerciseNoticeNode.Attributes["id"] != null) 
             {
                 exerciseNoticeIDRef_ = exerciseNoticeNode.Attributes["id"].Value;
                 ExerciseNotice ob = new ExerciseNotice(exerciseNoticeNode);
                 IDManager.SetID(exerciseNoticeIDRef_, ob);
             }
             else if (exerciseNoticeNode.Attributes["href"] != null)
             {
                 exerciseNoticeIDRef_ = exerciseNoticeNode.Attributes["href"].Value;
             }
             else
             {
                 exerciseNotice_ = new ExerciseNotice(exerciseNoticeNode);
             }
         }
         else
         {
             exerciseNotice_ = new ExerciseNotice(exerciseNoticeNode);
         }
     }
     
 
     XmlNode fallbackExerciseNode = xmlNode.SelectSingleNode("fallbackExercise");
     
     if (fallbackExerciseNode != null)
     {
         if (fallbackExerciseNode.Attributes["href"] != null || fallbackExerciseNode.Attributes["id"] != null) 
         {
             if (fallbackExerciseNode.Attributes["id"] != null) 
             {
                 fallbackExerciseIDRef_ = fallbackExerciseNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(fallbackExerciseNode);
                 IDManager.SetID(fallbackExerciseIDRef_, ob);
             }
             else if (fallbackExerciseNode.Attributes["href"] != null)
             {
                 fallbackExerciseIDRef_ = fallbackExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 fallbackExercise_ = new XsdTypeBoolean(fallbackExerciseNode);
             }
         }
         else
         {
             fallbackExercise_ = new XsdTypeBoolean(fallbackExerciseNode);
         }
     }
     
 
 }
 public NotDomesticCurrency(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode currencyNode = xmlNode.SelectSingleNode("currency");
     
     if (currencyNode != null)
     {
         if (currencyNode.Attributes["href"] != null || currencyNode.Attributes["id"] != null) 
         {
             if (currencyNode.Attributes["id"] != null) 
             {
                 currencyIDRef_ = currencyNode.Attributes["id"].Value;
                 Currency ob = new Currency(currencyNode);
                 IDManager.SetID(currencyIDRef_, ob);
             }
             else if (currencyNode.Attributes["href"] != null)
             {
                 currencyIDRef_ = currencyNode.Attributes["href"].Value;
             }
             else
             {
                 currency_ = new Currency(currencyNode);
             }
         }
         else
         {
             currency_ = new Currency(currencyNode);
         }
     }
     
 
 }
        public OilTransferDelivery(XmlNode xmlNode)
        {
            XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");

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

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


            XmlNodeList deliveryLocationNodeList = xmlNode.SelectNodes("deliveryLocation");

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

            foreach (XmlNode item in deliveryLocationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        deliveryLocationIDRef = item.Attributes["id"].Name;
                        CommodityDeliveryPoint ob = CommodityDeliveryPoint();
                        IDManager.SetID(deliveryLocationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        deliveryLocationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        deliveryLocation = new CommodityDeliveryPoint(item);
                    }
                }
            }
        }
 public DownEventCheck(XmlNode xmlNode)
 {
     XmlNode checkValueNode = xmlNode.SelectSingleNode("checkValue");
     
     if (checkValueNode != null)
     {
         if (checkValueNode.Attributes["href"] != null || checkValueNode.Attributes["id"] != null) 
         {
             if (checkValueNode.Attributes["id"] != null) 
             {
                 checkValueIDRef_ = checkValueNode.Attributes["id"].Value;
                 XsdTypeDouble ob = new XsdTypeDouble(checkValueNode);
                 IDManager.SetID(checkValueIDRef_, ob);
             }
             else if (checkValueNode.Attributes["href"] != null)
             {
                 checkValueIDRef_ = checkValueNode.Attributes["href"].Value;
             }
             else
             {
                 checkValue_ = new XsdTypeDouble(checkValueNode);
             }
         }
         else
         {
             checkValue_ = new XsdTypeDouble(checkValueNode);
         }
     }
     
 
     XmlNode equalityNode = xmlNode.SelectSingleNode("equality");
     
     if (equalityNode != null)
     {
         if (equalityNode.Attributes["href"] != null || equalityNode.Attributes["id"] != null) 
         {
             if (equalityNode.Attributes["id"] != null) 
             {
                 equalityIDRef_ = equalityNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(equalityNode);
                 IDManager.SetID(equalityIDRef_, ob);
             }
             else if (equalityNode.Attributes["href"] != null)
             {
                 equalityIDRef_ = equalityNode.Attributes["href"].Value;
             }
             else
             {
                 equality_ = new XsdTypeBoolean(equalityNode);
             }
         }
         else
         {
             equality_ = new XsdTypeBoolean(equalityNode);
         }
     }
     
 
 }
        public PCDeliverableObligationCharac(XmlNode xmlNode)
        {
            XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");

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

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


            XmlNodeList partialCashSettlementNodeList = xmlNode.SelectNodes("partialCashSettlement");

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

            foreach (XmlNode item in partialCashSettlementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        partialCashSettlementIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(partialCashSettlementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        partialCashSettlementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        partialCashSettlement = new XsdTypeBoolean(item);
                    }
                }
            }
        }
        public Function(XmlNode xmlNode)
        {
            XmlNodeList nameNodeList = xmlNode.SelectNodes("name");

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

            foreach (XmlNode item in nameNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        nameIDRef = item.Attributes["id"].Name;
                        XsdTypeToken ob = XsdTypeToken();
                        IDManager.SetID(nameIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        nameIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        name = new XsdTypeToken(item);
                    }
                }
            }


            XmlNodeList truefalseNodeList = xmlNode.SelectNodes("truefalse");

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

            foreach (XmlNode item in truefalseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        truefalseIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(truefalseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        truefalseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        truefalse = new XsdTypeBoolean(item);
                    }
                }
            }
        }
 public SubEvent(XmlNode xmlNode)
 {
     XmlNode refEventIDNode = xmlNode.SelectSingleNode("refEventID");
     
     if (refEventIDNode != null)
     {
         if (refEventIDNode.Attributes["href"] != null || refEventIDNode.Attributes["id"] != null) 
         {
             if (refEventIDNode.Attributes["id"] != null) 
             {
                 refEventIDIDRef_ = refEventIDNode.Attributes["id"].Value;
                 XsdTypeToken ob = new XsdTypeToken(refEventIDNode);
                 IDManager.SetID(refEventIDIDRef_, ob);
             }
             else if (refEventIDNode.Attributes["href"] != null)
             {
                 refEventIDIDRef_ = refEventIDNode.Attributes["href"].Value;
             }
             else
             {
                 refEventID_ = new XsdTypeToken(refEventIDNode);
             }
         }
         else
         {
             refEventID_ = new XsdTypeToken(refEventIDNode);
         }
     }
     
 
     XmlNode truefalseNode = xmlNode.SelectSingleNode("truefalse");
     
     if (truefalseNode != null)
     {
         if (truefalseNode.Attributes["href"] != null || truefalseNode.Attributes["id"] != null) 
         {
             if (truefalseNode.Attributes["id"] != null) 
             {
                 truefalseIDRef_ = truefalseNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(truefalseNode);
                 IDManager.SetID(truefalseIDRef_, ob);
             }
             else if (truefalseNode.Attributes["href"] != null)
             {
                 truefalseIDRef_ = truefalseNode.Attributes["href"].Value;
             }
             else
             {
                 truefalse_ = new XsdTypeBoolean(truefalseNode);
             }
         }
         else
         {
             truefalse_ = new XsdTypeBoolean(truefalseNode);
         }
     }
     
 
 }
Ejemplo n.º 32
0
        public ManualExercise(XmlNode xmlNode)
        {
            XmlNodeList exerciseNoticeNodeList = xmlNode.SelectNodes("exerciseNotice");

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

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


            XmlNodeList fallbackExerciseNodeList = xmlNode.SelectNodes("fallbackExercise");

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

            foreach (XmlNode item in fallbackExerciseNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fallbackExerciseIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(fallbackExerciseIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fallbackExerciseIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fallbackExercise = new XsdTypeBoolean(item);
                    }
                }
            }
        }
 public FloatingAmountProvisions(XmlNode xmlNode)
 {
     XmlNode WACCapInterestProvisionNode = xmlNode.SelectSingleNode("WACCapInterestProvision");
     
     if (WACCapInterestProvisionNode != null)
     {
         if (WACCapInterestProvisionNode.Attributes["href"] != null || WACCapInterestProvisionNode.Attributes["id"] != null) 
         {
             if (WACCapInterestProvisionNode.Attributes["id"] != null) 
             {
                 WACCapInterestProvisionIDRef_ = WACCapInterestProvisionNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(WACCapInterestProvisionNode);
                 IDManager.SetID(WACCapInterestProvisionIDRef_, ob);
             }
             else if (WACCapInterestProvisionNode.Attributes["href"] != null)
             {
                 WACCapInterestProvisionIDRef_ = WACCapInterestProvisionNode.Attributes["href"].Value;
             }
             else
             {
                 WACCapInterestProvision_ = new XsdTypeBoolean(WACCapInterestProvisionNode);
             }
         }
         else
         {
             WACCapInterestProvision_ = new XsdTypeBoolean(WACCapInterestProvisionNode);
         }
     }
     
 
     XmlNode stepUpProvisionNode = xmlNode.SelectSingleNode("stepUpProvision");
     
     if (stepUpProvisionNode != null)
     {
         if (stepUpProvisionNode.Attributes["href"] != null || stepUpProvisionNode.Attributes["id"] != null) 
         {
             if (stepUpProvisionNode.Attributes["id"] != null) 
             {
                 stepUpProvisionIDRef_ = stepUpProvisionNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(stepUpProvisionNode);
                 IDManager.SetID(stepUpProvisionIDRef_, ob);
             }
             else if (stepUpProvisionNode.Attributes["href"] != null)
             {
                 stepUpProvisionIDRef_ = stepUpProvisionNode.Attributes["href"].Value;
             }
             else
             {
                 stepUpProvision_ = new XsdTypeBoolean(stepUpProvisionNode);
             }
         }
         else
         {
             stepUpProvision_ = new XsdTypeBoolean(stepUpProvisionNode);
         }
     }
     
 
 }
Ejemplo n.º 34
0
        public FloatingAmountProvisions(XmlNode xmlNode)
        {
            XmlNodeList WACCapInterestProvisionNodeList = xmlNode.SelectNodes("WACCapInterestProvision");

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

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


            XmlNodeList stepUpProvisionNodeList = xmlNode.SelectNodes("stepUpProvision");

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

            foreach (XmlNode item in stepUpProvisionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        stepUpProvisionIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(stepUpProvisionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        stepUpProvisionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        stepUpProvision = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 35
0
        public UpEventCheck(XmlNode xmlNode)
        {
            XmlNodeList checkValueNodeList = xmlNode.SelectNodes("checkValue");

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

            foreach (XmlNode item in checkValueNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        checkValueIDRef = item.Attributes["id"].Name;
                        XsdTypeDouble ob = XsdTypeDouble();
                        IDManager.SetID(checkValueIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        checkValueIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        checkValue = new XsdTypeDouble(item);
                    }
                }
            }


            XmlNodeList equalityNodeList = xmlNode.SelectNodes("equality");

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

            foreach (XmlNode item in equalityNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        equalityIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(equalityIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        equalityIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        equality = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 36
0
        public NotDomesticCurrency(XmlNode xmlNode)
        {
            XmlNodeList applicableNodeList = xmlNode.SelectNodes("applicable");

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

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


            XmlNodeList currencyNodeList = xmlNode.SelectNodes("currency");

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

            foreach (XmlNode item in currencyNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        currencyIDRef = item.Attributes["id"].Name;
                        Currency ob = Currency();
                        IDManager.SetID(currencyIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        currencyIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        currency = new Currency(item);
                    }
                }
            }
        }
 public FxBoundary(XmlNode xmlNode)
 {
     XmlNode inclusiveNode = xmlNode.SelectSingleNode("inclusive");
     
     if (inclusiveNode != null)
     {
         if (inclusiveNode.Attributes["href"] != null || inclusiveNode.Attributes["id"] != null) 
         {
             if (inclusiveNode.Attributes["id"] != null) 
             {
                 inclusiveIDRef_ = inclusiveNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(inclusiveNode);
                 IDManager.SetID(inclusiveIDRef_, ob);
             }
             else if (inclusiveNode.Attributes["href"] != null)
             {
                 inclusiveIDRef_ = inclusiveNode.Attributes["href"].Value;
             }
             else
             {
                 inclusive_ = new XsdTypeBoolean(inclusiveNode);
             }
         }
         else
         {
             inclusive_ = new XsdTypeBoolean(inclusiveNode);
         }
     }
     
 
     XmlNode exclusiveNode = xmlNode.SelectSingleNode("exclusive");
     
     if (exclusiveNode != null)
     {
         if (exclusiveNode.Attributes["href"] != null || exclusiveNode.Attributes["id"] != null) 
         {
             if (exclusiveNode.Attributes["id"] != null) 
             {
                 exclusiveIDRef_ = exclusiveNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(exclusiveNode);
                 IDManager.SetID(exclusiveIDRef_, ob);
             }
             else if (exclusiveNode.Attributes["href"] != null)
             {
                 exclusiveIDRef_ = exclusiveNode.Attributes["href"].Value;
             }
             else
             {
                 exclusive_ = new XsdTypeBoolean(exclusiveNode);
             }
         }
         else
         {
             exclusive_ = new XsdTypeBoolean(exclusiveNode);
         }
     }
     
 
 }
 public ElectricityDeliverySystemFirm(XmlNode xmlNode)
 {
     XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");
     
     if (applicableNode != null)
     {
         if (applicableNode.Attributes["href"] != null || applicableNode.Attributes["id"] != null) 
         {
             if (applicableNode.Attributes["id"] != null) 
             {
                 applicableIDRef_ = applicableNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(applicableNode);
                 IDManager.SetID(applicableIDRef_, ob);
             }
             else if (applicableNode.Attributes["href"] != null)
             {
                 applicableIDRef_ = applicableNode.Attributes["href"].Value;
             }
             else
             {
                 applicable_ = new XsdTypeBoolean(applicableNode);
             }
         }
         else
         {
             applicable_ = new XsdTypeBoolean(applicableNode);
         }
     }
     
 
     XmlNode systemNode = xmlNode.SelectSingleNode("system");
     
     if (systemNode != null)
     {
         if (systemNode.Attributes["href"] != null || systemNode.Attributes["id"] != null) 
         {
             if (systemNode.Attributes["id"] != null) 
             {
                 systemIDRef_ = systemNode.Attributes["id"].Value;
                 CommodityDeliveryPoint ob = new CommodityDeliveryPoint(systemNode);
                 IDManager.SetID(systemIDRef_, ob);
             }
             else if (systemNode.Attributes["href"] != null)
             {
                 systemIDRef_ = systemNode.Attributes["href"].Value;
             }
             else
             {
                 system_ = new CommodityDeliveryPoint(systemNode);
             }
         }
         else
         {
             system_ = new CommodityDeliveryPoint(systemNode);
         }
     }
     
 
 }
Ejemplo n.º 39
0
        public FxBoundary(XmlNode xmlNode)
        {
            XmlNodeList inclusiveNodeList = xmlNode.SelectNodes("inclusive");

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

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


            XmlNodeList exclusiveNodeList = xmlNode.SelectNodes("exclusive");

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

            foreach (XmlNode item in exclusiveNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exclusiveIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(exclusiveIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exclusiveIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exclusive = new XsdTypeBoolean(item);
                    }
                }
            }
        }
Ejemplo n.º 40
0
        public AndEventCal(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode eventCalculationListNode = xmlNode.SelectSingleNode("eventCalculationList");

            if (eventCalculationListNode != null)
            {
                if (eventCalculationListNode.Attributes["href"] != null || eventCalculationListNode.Attributes["id"] != null)
                {
                    if (eventCalculationListNode.Attributes["id"] != null)
                    {
                        eventCalculationListIDRef_ = eventCalculationListNode.Attributes["id"].Value;
                        EventCalculationList ob = new EventCalculationList(eventCalculationListNode);
                        IDManager.SetID(eventCalculationListIDRef_, ob);
                    }
                    else if (eventCalculationListNode.Attributes["href"] != null)
                    {
                        eventCalculationListIDRef_ = eventCalculationListNode.Attributes["href"].Value;
                    }
                    else
                    {
                        eventCalculationList_ = new EventCalculationList(eventCalculationListNode);
                    }
                }
                else
                {
                    eventCalculationList_ = new EventCalculationList(eventCalculationListNode);
                }
            }


            XmlNode complementNode = xmlNode.SelectSingleNode("complement");

            if (complementNode != null)
            {
                if (complementNode.Attributes["href"] != null || complementNode.Attributes["id"] != null)
                {
                    if (complementNode.Attributes["id"] != null)
                    {
                        complementIDRef_ = complementNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(complementNode);
                        IDManager.SetID(complementIDRef_, ob);
                    }
                    else if (complementNode.Attributes["href"] != null)
                    {
                        complementIDRef_ = complementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        complement_ = new XsdTypeBoolean(complementNode);
                    }
                }
                else
                {
                    complement_ = new XsdTypeBoolean(complementNode);
                }
            }
        }
Ejemplo n.º 41
0
        public ReportIdentification(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode numberOfSectionsNode = xmlNode.SelectSingleNode("numberOfSections");

            if (numberOfSectionsNode != null)
            {
                if (numberOfSectionsNode.Attributes["href"] != null || numberOfSectionsNode.Attributes["id"] != null)
                {
                    if (numberOfSectionsNode.Attributes["id"] != null)
                    {
                        numberOfSectionsIDRef_ = numberOfSectionsNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberOfSectionsNode);
                        IDManager.SetID(numberOfSectionsIDRef_, ob);
                    }
                    else if (numberOfSectionsNode.Attributes["href"] != null)
                    {
                        numberOfSectionsIDRef_ = numberOfSectionsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        numberOfSections_ = new XsdTypePositiveInteger(numberOfSectionsNode);
                    }
                }
                else
                {
                    numberOfSections_ = new XsdTypePositiveInteger(numberOfSectionsNode);
                }
            }


            XmlNode submissionsCompleteNode = xmlNode.SelectSingleNode("submissionsComplete");

            if (submissionsCompleteNode != null)
            {
                if (submissionsCompleteNode.Attributes["href"] != null || submissionsCompleteNode.Attributes["id"] != null)
                {
                    if (submissionsCompleteNode.Attributes["id"] != null)
                    {
                        submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(submissionsCompleteNode);
                        IDManager.SetID(submissionsCompleteIDRef_, ob);
                    }
                    else if (submissionsCompleteNode.Attributes["href"] != null)
                    {
                        submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["href"].Value;
                    }
                    else
                    {
                        submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
                    }
                }
                else
                {
                    submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
                }
            }
        }
        public MutualFund(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode openEndedFundNode = xmlNode.SelectSingleNode("openEndedFund");

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


            XmlNode fundManagerNode = xmlNode.SelectSingleNode("fundManager");

            if (fundManagerNode != null)
            {
                if (fundManagerNode.Attributes["href"] != null || fundManagerNode.Attributes["id"] != null)
                {
                    if (fundManagerNode.Attributes["id"] != null)
                    {
                        fundManagerIDRef_ = fundManagerNode.Attributes["id"].Value;
                        XsdTypeString ob = new XsdTypeString(fundManagerNode);
                        IDManager.SetID(fundManagerIDRef_, ob);
                    }
                    else if (fundManagerNode.Attributes["href"] != null)
                    {
                        fundManagerIDRef_ = fundManagerNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fundManager_ = new XsdTypeString(fundManagerNode);
                    }
                }
                else
                {
                    fundManager_ = new XsdTypeString(fundManagerNode);
                }
            }
        }
        public PortfolioReference(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode sequenceNumberNode = xmlNode.SelectSingleNode("sequenceNumber");

            if (sequenceNumberNode != null)
            {
                if (sequenceNumberNode.Attributes["href"] != null || sequenceNumberNode.Attributes["id"] != null)
                {
                    if (sequenceNumberNode.Attributes["id"] != null)
                    {
                        sequenceNumberIDRef_ = sequenceNumberNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sequenceNumberNode);
                        IDManager.SetID(sequenceNumberIDRef_, ob);
                    }
                    else if (sequenceNumberNode.Attributes["href"] != null)
                    {
                        sequenceNumberIDRef_ = sequenceNumberNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
                    }
                }
                else
                {
                    sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
                }
            }


            XmlNode submissionsCompleteNode = xmlNode.SelectSingleNode("submissionsComplete");

            if (submissionsCompleteNode != null)
            {
                if (submissionsCompleteNode.Attributes["href"] != null || submissionsCompleteNode.Attributes["id"] != null)
                {
                    if (submissionsCompleteNode.Attributes["id"] != null)
                    {
                        submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(submissionsCompleteNode);
                        IDManager.SetID(submissionsCompleteIDRef_, ob);
                    }
                    else if (submissionsCompleteNode.Attributes["href"] != null)
                    {
                        submissionsCompleteIDRef_ = submissionsCompleteNode.Attributes["href"].Value;
                    }
                    else
                    {
                        submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
                    }
                }
                else
                {
                    submissionsComplete_ = new XsdTypeBoolean(submissionsCompleteNode);
                }
            }
        }
Ejemplo n.º 44
0
        public ElectricityDeliverySystemFirm(XmlNode xmlNode)
        {
            XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");

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


            XmlNode systemNode = xmlNode.SelectSingleNode("system");

            if (systemNode != null)
            {
                if (systemNode.Attributes["href"] != null || systemNode.Attributes["id"] != null)
                {
                    if (systemNode.Attributes["id"] != null)
                    {
                        systemIDRef_ = systemNode.Attributes["id"].Value;
                        CommodityDeliveryPoint ob = new CommodityDeliveryPoint(systemNode);
                        IDManager.SetID(systemIDRef_, ob);
                    }
                    else if (systemNode.Attributes["href"] != null)
                    {
                        systemIDRef_ = systemNode.Attributes["href"].Value;
                    }
                    else
                    {
                        system_ = new CommodityDeliveryPoint(systemNode);
                    }
                }
                else
                {
                    system_ = new CommodityDeliveryPoint(systemNode);
                }
            }
        }
        public PCDeliverableObligationCharac(XmlNode xmlNode)
        {
            XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");

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


            XmlNode partialCashSettlementNode = xmlNode.SelectSingleNode("partialCashSettlement");

            if (partialCashSettlementNode != null)
            {
                if (partialCashSettlementNode.Attributes["href"] != null || partialCashSettlementNode.Attributes["id"] != null)
                {
                    if (partialCashSettlementNode.Attributes["id"] != null)
                    {
                        partialCashSettlementIDRef_ = partialCashSettlementNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(partialCashSettlementNode);
                        IDManager.SetID(partialCashSettlementIDRef_, ob);
                    }
                    else if (partialCashSettlementNode.Attributes["href"] != null)
                    {
                        partialCashSettlementIDRef_ = partialCashSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        partialCashSettlement_ = new XsdTypeBoolean(partialCashSettlementNode);
                    }
                }
                else
                {
                    partialCashSettlement_ = new XsdTypeBoolean(partialCashSettlementNode);
                }
            }
        }
        public Function(XmlNode xmlNode)
        {
            XmlNode nameNode = xmlNode.SelectSingleNode("name");

            if (nameNode != null)
            {
                if (nameNode.Attributes["href"] != null || nameNode.Attributes["id"] != null)
                {
                    if (nameNode.Attributes["id"] != null)
                    {
                        nameIDRef_ = nameNode.Attributes["id"].Value;
                        XsdTypeToken ob = new XsdTypeToken(nameNode);
                        IDManager.SetID(nameIDRef_, ob);
                    }
                    else if (nameNode.Attributes["href"] != null)
                    {
                        nameIDRef_ = nameNode.Attributes["href"].Value;
                    }
                    else
                    {
                        name_ = new XsdTypeToken(nameNode);
                    }
                }
                else
                {
                    name_ = new XsdTypeToken(nameNode);
                }
            }


            XmlNode truefalseNode = xmlNode.SelectSingleNode("truefalse");

            if (truefalseNode != null)
            {
                if (truefalseNode.Attributes["href"] != null || truefalseNode.Attributes["id"] != null)
                {
                    if (truefalseNode.Attributes["id"] != null)
                    {
                        truefalseIDRef_ = truefalseNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(truefalseNode);
                        IDManager.SetID(truefalseIDRef_, ob);
                    }
                    else if (truefalseNode.Attributes["href"] != null)
                    {
                        truefalseIDRef_ = truefalseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        truefalse_ = new XsdTypeBoolean(truefalseNode);
                    }
                }
                else
                {
                    truefalse_ = new XsdTypeBoolean(truefalseNode);
                }
            }
        }
        public ManualExercise(XmlNode xmlNode)
        {
            XmlNode exerciseNoticeNode = xmlNode.SelectSingleNode("exerciseNotice");

            if (exerciseNoticeNode != null)
            {
                if (exerciseNoticeNode.Attributes["href"] != null || exerciseNoticeNode.Attributes["id"] != null)
                {
                    if (exerciseNoticeNode.Attributes["id"] != null)
                    {
                        exerciseNoticeIDRef_ = exerciseNoticeNode.Attributes["id"].Value;
                        ExerciseNotice ob = new ExerciseNotice(exerciseNoticeNode);
                        IDManager.SetID(exerciseNoticeIDRef_, ob);
                    }
                    else if (exerciseNoticeNode.Attributes["href"] != null)
                    {
                        exerciseNoticeIDRef_ = exerciseNoticeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        exerciseNotice_ = new ExerciseNotice(exerciseNoticeNode);
                    }
                }
                else
                {
                    exerciseNotice_ = new ExerciseNotice(exerciseNoticeNode);
                }
            }


            XmlNode fallbackExerciseNode = xmlNode.SelectSingleNode("fallbackExercise");

            if (fallbackExerciseNode != null)
            {
                if (fallbackExerciseNode.Attributes["href"] != null || fallbackExerciseNode.Attributes["id"] != null)
                {
                    if (fallbackExerciseNode.Attributes["id"] != null)
                    {
                        fallbackExerciseIDRef_ = fallbackExerciseNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(fallbackExerciseNode);
                        IDManager.SetID(fallbackExerciseIDRef_, ob);
                    }
                    else if (fallbackExerciseNode.Attributes["href"] != null)
                    {
                        fallbackExerciseIDRef_ = fallbackExerciseNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fallbackExercise_ = new XsdTypeBoolean(fallbackExerciseNode);
                    }
                }
                else
                {
                    fallbackExercise_ = new XsdTypeBoolean(fallbackExerciseNode);
                }
            }
        }
        public FloatingAmountProvisions(XmlNode xmlNode)
        {
            XmlNode WACCapInterestProvisionNode = xmlNode.SelectSingleNode("WACCapInterestProvision");

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


            XmlNode stepUpProvisionNode = xmlNode.SelectSingleNode("stepUpProvision");

            if (stepUpProvisionNode != null)
            {
                if (stepUpProvisionNode.Attributes["href"] != null || stepUpProvisionNode.Attributes["id"] != null)
                {
                    if (stepUpProvisionNode.Attributes["id"] != null)
                    {
                        stepUpProvisionIDRef_ = stepUpProvisionNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(stepUpProvisionNode);
                        IDManager.SetID(stepUpProvisionIDRef_, ob);
                    }
                    else if (stepUpProvisionNode.Attributes["href"] != null)
                    {
                        stepUpProvisionIDRef_ = stepUpProvisionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        stepUpProvision_ = new XsdTypeBoolean(stepUpProvisionNode);
                    }
                }
                else
                {
                    stepUpProvision_ = new XsdTypeBoolean(stepUpProvisionNode);
                }
            }
        }
        public DownEventCheck(XmlNode xmlNode)
        {
            XmlNode checkValueNode = xmlNode.SelectSingleNode("checkValue");

            if (checkValueNode != null)
            {
                if (checkValueNode.Attributes["href"] != null || checkValueNode.Attributes["id"] != null)
                {
                    if (checkValueNode.Attributes["id"] != null)
                    {
                        checkValueIDRef_ = checkValueNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(checkValueNode);
                        IDManager.SetID(checkValueIDRef_, ob);
                    }
                    else if (checkValueNode.Attributes["href"] != null)
                    {
                        checkValueIDRef_ = checkValueNode.Attributes["href"].Value;
                    }
                    else
                    {
                        checkValue_ = new XsdTypeDouble(checkValueNode);
                    }
                }
                else
                {
                    checkValue_ = new XsdTypeDouble(checkValueNode);
                }
            }


            XmlNode equalityNode = xmlNode.SelectSingleNode("equality");

            if (equalityNode != null)
            {
                if (equalityNode.Attributes["href"] != null || equalityNode.Attributes["id"] != null)
                {
                    if (equalityNode.Attributes["id"] != null)
                    {
                        equalityIDRef_ = equalityNode.Attributes["id"].Value;
                        XsdTypeBoolean ob = new XsdTypeBoolean(equalityNode);
                        IDManager.SetID(equalityIDRef_, ob);
                    }
                    else if (equalityNode.Attributes["href"] != null)
                    {
                        equalityIDRef_ = equalityNode.Attributes["href"].Value;
                    }
                    else
                    {
                        equality_ = new XsdTypeBoolean(equalityNode);
                    }
                }
                else
                {
                    equality_ = new XsdTypeBoolean(equalityNode);
                }
            }
        }
 public GenericProduct(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode multiLegNode = xmlNode.SelectSingleNode("multiLeg");
     
     if (multiLegNode != null)
     {
         if (multiLegNode.Attributes["href"] != null || multiLegNode.Attributes["id"] != null) 
         {
             if (multiLegNode.Attributes["id"] != null) 
             {
                 multiLegIDRef_ = multiLegNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(multiLegNode);
                 IDManager.SetID(multiLegIDRef_, ob);
             }
             else if (multiLegNode.Attributes["href"] != null)
             {
                 multiLegIDRef_ = multiLegNode.Attributes["href"].Value;
             }
             else
             {
                 multiLeg_ = new XsdTypeBoolean(multiLegNode);
             }
         }
         else
         {
             multiLeg_ = new XsdTypeBoolean(multiLegNode);
         }
     }
     
 
     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 counterpartyReferenceNodeList = xmlNode.SelectNodes("counterpartyReference");
     
     if (counterpartyReferenceNodeList != null)
     {
         this.counterpartyReference_ = new List<PartyReference>();
         foreach (XmlNode item in counterpartyReferenceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     counterpartyReferenceIDRef_ = item.Attributes["id"].Value;
                     counterpartyReference_.Add(new PartyReference(item));
                     IDManager.SetID(counterpartyReferenceIDRef_, counterpartyReference_[counterpartyReference_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     counterpartyReferenceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 counterpartyReference_.Add(new PartyReference(item));
                 }
             }
             else
             {
                 counterpartyReference_.Add(new PartyReference(item));
             }
         }
     }
     
 
     XmlNode premiumNode = xmlNode.SelectSingleNode("premium");
     
     if (premiumNode != null)
     {
         if (premiumNode.Attributes["href"] != null || premiumNode.Attributes["id"] != null) 
         {
             if (premiumNode.Attributes["id"] != null) 
             {
                 premiumIDRef_ = premiumNode.Attributes["id"].Value;
                 SimplePayment ob = new SimplePayment(premiumNode);
                 IDManager.SetID(premiumIDRef_, ob);
             }
             else if (premiumNode.Attributes["href"] != null)
             {
                 premiumIDRef_ = premiumNode.Attributes["href"].Value;
             }
             else
             {
                 premium_ = new SimplePayment(premiumNode);
             }
         }
         else
         {
             premium_ = new SimplePayment(premiumNode);
         }
     }
     
 
     XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");
     
     if (effectiveDateNode != null)
     {
         if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null) 
         {
             if (effectiveDateNode.Attributes["id"] != null) 
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                 AdjustableDate2 ob = new AdjustableDate2(effectiveDateNode);
                 IDManager.SetID(effectiveDateIDRef_, ob);
             }
             else if (effectiveDateNode.Attributes["href"] != null)
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
             }
             else
             {
                 effectiveDate_ = new AdjustableDate2(effectiveDateNode);
             }
         }
         else
         {
             effectiveDate_ = new AdjustableDate2(effectiveDateNode);
         }
     }
     
 
     XmlNode expirationDateNode = xmlNode.SelectSingleNode("expirationDate");
     
     if (expirationDateNode != null)
     {
         if (expirationDateNode.Attributes["href"] != null || expirationDateNode.Attributes["id"] != null) 
         {
             if (expirationDateNode.Attributes["id"] != null) 
             {
                 expirationDateIDRef_ = expirationDateNode.Attributes["id"].Value;
                 AdjustableDate2 ob = new AdjustableDate2(expirationDateNode);
                 IDManager.SetID(expirationDateIDRef_, ob);
             }
             else if (expirationDateNode.Attributes["href"] != null)
             {
                 expirationDateIDRef_ = expirationDateNode.Attributes["href"].Value;
             }
             else
             {
                 expirationDate_ = new AdjustableDate2(expirationDateNode);
             }
         }
         else
         {
             expirationDate_ = new AdjustableDate2(expirationDateNode);
         }
     }
     
 
     XmlNode terminationDateNode = xmlNode.SelectSingleNode("terminationDate");
     
     if (terminationDateNode != null)
     {
         if (terminationDateNode.Attributes["href"] != null || terminationDateNode.Attributes["id"] != null) 
         {
             if (terminationDateNode.Attributes["id"] != null) 
             {
                 terminationDateIDRef_ = terminationDateNode.Attributes["id"].Value;
                 AdjustableDate2 ob = new AdjustableDate2(terminationDateNode);
                 IDManager.SetID(terminationDateIDRef_, ob);
             }
             else if (terminationDateNode.Attributes["href"] != null)
             {
                 terminationDateIDRef_ = terminationDateNode.Attributes["href"].Value;
             }
             else
             {
                 terminationDate_ = new AdjustableDate2(terminationDateNode);
             }
         }
         else
         {
             terminationDate_ = new AdjustableDate2(terminationDateNode);
         }
     }
     
 
     XmlNodeList underlyerNodeList = xmlNode.SelectNodes("underlyer");
     
     if (underlyerNodeList != null)
     {
         this.underlyer_ = new List<TradeUnderlyer2>();
         foreach (XmlNode item in underlyerNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     underlyerIDRef_ = item.Attributes["id"].Value;
                     underlyer_.Add(new TradeUnderlyer2(item));
                     IDManager.SetID(underlyerIDRef_, underlyer_[underlyer_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     underlyerIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 underlyer_.Add(new TradeUnderlyer2(item));
                 }
             }
             else
             {
                 underlyer_.Add(new TradeUnderlyer2(item));
             }
         }
     }
     
 
     XmlNodeList notionalNodeList = xmlNode.SelectNodes("notional");
     
     if (notionalNodeList != null)
     {
         this.notional_ = new List<CashflowNotional>();
         foreach (XmlNode item in notionalNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     notionalIDRef_ = item.Attributes["id"].Value;
                     notional_.Add(new CashflowNotional(item));
                     IDManager.SetID(notionalIDRef_, notional_[notional_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     notionalIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 notional_.Add(new CashflowNotional(item));
                 }
             }
             else
             {
                 notional_.Add(new CashflowNotional(item));
             }
         }
     }
     
 
     XmlNode optionTypeNode = xmlNode.SelectSingleNode("optionType");
     
     if (optionTypeNode != null)
     {
         if (optionTypeNode.Attributes["href"] != null || optionTypeNode.Attributes["id"] != null) 
         {
             if (optionTypeNode.Attributes["id"] != null) 
             {
                 optionTypeIDRef_ = optionTypeNode.Attributes["id"].Value;
                 OptionType ob = new OptionType(optionTypeNode);
                 IDManager.SetID(optionTypeIDRef_, ob);
             }
             else if (optionTypeNode.Attributes["href"] != null)
             {
                 optionTypeIDRef_ = optionTypeNode.Attributes["href"].Value;
             }
             else
             {
                 optionType_ = new OptionType(optionTypeNode);
             }
         }
         else
         {
             optionType_ = new OptionType(optionTypeNode);
         }
     }
     
 
     XmlNodeList settlementCurrencyNodeList = xmlNode.SelectNodes("settlementCurrency");
     
     if (settlementCurrencyNodeList != null)
     {
         this.settlementCurrency_ = new List<IdentifiedCurrency>();
         foreach (XmlNode item in settlementCurrencyNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     settlementCurrencyIDRef_ = item.Attributes["id"].Value;
                     settlementCurrency_.Add(new IdentifiedCurrency(item));
                     IDManager.SetID(settlementCurrencyIDRef_, settlementCurrency_[settlementCurrency_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     settlementCurrencyIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 settlementCurrency_.Add(new IdentifiedCurrency(item));
                 }
             }
             else
             {
                 settlementCurrency_.Add(new IdentifiedCurrency(item));
             }
         }
     }
     
 
     XmlNodeList dayCountFractionNodeList = xmlNode.SelectNodes("dayCountFraction");
     
     if (dayCountFractionNodeList != null)
     {
         this.dayCountFraction_ = new List<DayCountFraction>();
         foreach (XmlNode item in dayCountFractionNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     dayCountFractionIDRef_ = item.Attributes["id"].Value;
                     dayCountFraction_.Add(new DayCountFraction(item));
                     IDManager.SetID(dayCountFractionIDRef_, dayCountFraction_[dayCountFraction_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     dayCountFractionIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 dayCountFraction_.Add(new DayCountFraction(item));
                 }
             }
             else
             {
                 dayCountFraction_.Add(new DayCountFraction(item));
             }
         }
     }
     
 
 }
 public CommodityPhysicalExercise(XmlNode xmlNode)
 {
     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;
                 CommodityPhysicalAmericanExercise ob = new CommodityPhysicalAmericanExercise(americanExerciseNode);
                 IDManager.SetID(americanExerciseIDRef_, ob);
             }
             else if (americanExerciseNode.Attributes["href"] != null)
             {
                 americanExerciseIDRef_ = americanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 americanExercise_ = new CommodityPhysicalAmericanExercise(americanExerciseNode);
             }
         }
         else
         {
             americanExercise_ = new CommodityPhysicalAmericanExercise(americanExerciseNode);
         }
     }
     
 
     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;
                 CommodityPhysicalEuropeanExercise ob = new CommodityPhysicalEuropeanExercise(europeanExerciseNode);
                 IDManager.SetID(europeanExerciseIDRef_, ob);
             }
             else if (europeanExerciseNode.Attributes["href"] != null)
             {
                 europeanExerciseIDRef_ = europeanExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 europeanExercise_ = new CommodityPhysicalEuropeanExercise(europeanExerciseNode);
             }
         }
         else
         {
             europeanExercise_ = new CommodityPhysicalEuropeanExercise(europeanExerciseNode);
         }
     }
     
 
     XmlNode automaticExerciseNode = xmlNode.SelectSingleNode("automaticExercise");
     
     if (automaticExerciseNode != null)
     {
         if (automaticExerciseNode.Attributes["href"] != null || automaticExerciseNode.Attributes["id"] != null) 
         {
             if (automaticExerciseNode.Attributes["id"] != null) 
             {
                 automaticExerciseIDRef_ = automaticExerciseNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(automaticExerciseNode);
                 IDManager.SetID(automaticExerciseIDRef_, ob);
             }
             else if (automaticExerciseNode.Attributes["href"] != null)
             {
                 automaticExerciseIDRef_ = automaticExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 automaticExercise_ = new XsdTypeBoolean(automaticExerciseNode);
             }
         }
         else
         {
             automaticExercise_ = new XsdTypeBoolean(automaticExerciseNode);
         }
     }
     
 
     XmlNode writtenConfirmationNode = xmlNode.SelectSingleNode("writtenConfirmation");
     
     if (writtenConfirmationNode != null)
     {
         if (writtenConfirmationNode.Attributes["href"] != null || writtenConfirmationNode.Attributes["id"] != null) 
         {
             if (writtenConfirmationNode.Attributes["id"] != null) 
             {
                 writtenConfirmationIDRef_ = writtenConfirmationNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(writtenConfirmationNode);
                 IDManager.SetID(writtenConfirmationIDRef_, ob);
             }
             else if (writtenConfirmationNode.Attributes["href"] != null)
             {
                 writtenConfirmationIDRef_ = writtenConfirmationNode.Attributes["href"].Value;
             }
             else
             {
                 writtenConfirmation_ = new XsdTypeBoolean(writtenConfirmationNode);
             }
         }
         else
         {
             writtenConfirmation_ = new XsdTypeBoolean(writtenConfirmationNode);
         }
     }
     
 
 }
 public Cashflows(XmlNode xmlNode)
 {
     XmlNode cashflowsMatchParametersNode = xmlNode.SelectSingleNode("cashflowsMatchParameters");
     
     if (cashflowsMatchParametersNode != null)
     {
         if (cashflowsMatchParametersNode.Attributes["href"] != null || cashflowsMatchParametersNode.Attributes["id"] != null) 
         {
             if (cashflowsMatchParametersNode.Attributes["id"] != null) 
             {
                 cashflowsMatchParametersIDRef_ = cashflowsMatchParametersNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(cashflowsMatchParametersNode);
                 IDManager.SetID(cashflowsMatchParametersIDRef_, ob);
             }
             else if (cashflowsMatchParametersNode.Attributes["href"] != null)
             {
                 cashflowsMatchParametersIDRef_ = cashflowsMatchParametersNode.Attributes["href"].Value;
             }
             else
             {
                 cashflowsMatchParameters_ = new XsdTypeBoolean(cashflowsMatchParametersNode);
             }
         }
         else
         {
             cashflowsMatchParameters_ = new XsdTypeBoolean(cashflowsMatchParametersNode);
         }
     }
     
 
     XmlNodeList principalExchangeNodeList = xmlNode.SelectNodes("principalExchange");
     
     if (principalExchangeNodeList != null)
     {
         this.principalExchange_ = new List<PrincipalExchange>();
         foreach (XmlNode item in principalExchangeNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     principalExchangeIDRef_ = item.Attributes["id"].Value;
                     principalExchange_.Add(new PrincipalExchange(item));
                     IDManager.SetID(principalExchangeIDRef_, principalExchange_[principalExchange_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     principalExchangeIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 principalExchange_.Add(new PrincipalExchange(item));
                 }
             }
             else
             {
                 principalExchange_.Add(new PrincipalExchange(item));
             }
         }
     }
     
 
     XmlNodeList paymentCalculationPeriodNodeList = xmlNode.SelectNodes("paymentCalculationPeriod");
     
     if (paymentCalculationPeriodNodeList != null)
     {
         this.paymentCalculationPeriod_ = new List<PaymentCalculationPeriod>();
         foreach (XmlNode item in paymentCalculationPeriodNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     paymentCalculationPeriodIDRef_ = item.Attributes["id"].Value;
                     paymentCalculationPeriod_.Add(new PaymentCalculationPeriod(item));
                     IDManager.SetID(paymentCalculationPeriodIDRef_, paymentCalculationPeriod_[paymentCalculationPeriod_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     paymentCalculationPeriodIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 paymentCalculationPeriod_.Add(new PaymentCalculationPeriod(item));
                 }
             }
             else
             {
                 paymentCalculationPeriod_.Add(new PaymentCalculationPeriod(item));
             }
         }
     }
     
 
 }
 public DividendLeg(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode declaredCashDividendPercentageNode = xmlNode.SelectSingleNode("declaredCashDividendPercentage");
     
     if (declaredCashDividendPercentageNode != null)
     {
         if (declaredCashDividendPercentageNode.Attributes["href"] != null || declaredCashDividendPercentageNode.Attributes["id"] != null) 
         {
             if (declaredCashDividendPercentageNode.Attributes["id"] != null) 
             {
                 declaredCashDividendPercentageIDRef_ = declaredCashDividendPercentageNode.Attributes["id"].Value;
                 NonNegativeDecimal ob = new NonNegativeDecimal(declaredCashDividendPercentageNode);
                 IDManager.SetID(declaredCashDividendPercentageIDRef_, ob);
             }
             else if (declaredCashDividendPercentageNode.Attributes["href"] != null)
             {
                 declaredCashDividendPercentageIDRef_ = declaredCashDividendPercentageNode.Attributes["href"].Value;
             }
             else
             {
                 declaredCashDividendPercentage_ = new NonNegativeDecimal(declaredCashDividendPercentageNode);
             }
         }
         else
         {
             declaredCashDividendPercentage_ = new NonNegativeDecimal(declaredCashDividendPercentageNode);
         }
     }
     
 
     XmlNode declaredCashEquivalentDividendPercentageNode = xmlNode.SelectSingleNode("declaredCashEquivalentDividendPercentage");
     
     if (declaredCashEquivalentDividendPercentageNode != null)
     {
         if (declaredCashEquivalentDividendPercentageNode.Attributes["href"] != null || declaredCashEquivalentDividendPercentageNode.Attributes["id"] != null) 
         {
             if (declaredCashEquivalentDividendPercentageNode.Attributes["id"] != null) 
             {
                 declaredCashEquivalentDividendPercentageIDRef_ = declaredCashEquivalentDividendPercentageNode.Attributes["id"].Value;
                 NonNegativeDecimal ob = new NonNegativeDecimal(declaredCashEquivalentDividendPercentageNode);
                 IDManager.SetID(declaredCashEquivalentDividendPercentageIDRef_, ob);
             }
             else if (declaredCashEquivalentDividendPercentageNode.Attributes["href"] != null)
             {
                 declaredCashEquivalentDividendPercentageIDRef_ = declaredCashEquivalentDividendPercentageNode.Attributes["href"].Value;
             }
             else
             {
                 declaredCashEquivalentDividendPercentage_ = new NonNegativeDecimal(declaredCashEquivalentDividendPercentageNode);
             }
         }
         else
         {
             declaredCashEquivalentDividendPercentage_ = new NonNegativeDecimal(declaredCashEquivalentDividendPercentageNode);
         }
     }
     
 
     XmlNodeList dividendPeriodNodeList = xmlNode.SelectNodes("dividendPeriod");
     
     if (dividendPeriodNodeList != null)
     {
         this.dividendPeriod_ = new List<DividendPeriodPayment>();
         foreach (XmlNode item in dividendPeriodNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     dividendPeriodIDRef_ = item.Attributes["id"].Value;
                     dividendPeriod_.Add(new DividendPeriodPayment(item));
                     IDManager.SetID(dividendPeriodIDRef_, dividendPeriod_[dividendPeriod_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     dividendPeriodIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 dividendPeriod_.Add(new DividendPeriodPayment(item));
                 }
             }
             else
             {
                 dividendPeriod_.Add(new DividendPeriodPayment(item));
             }
         }
     }
     
 
     XmlNode specialDividendsNode = xmlNode.SelectSingleNode("specialDividends");
     
     if (specialDividendsNode != null)
     {
         if (specialDividendsNode.Attributes["href"] != null || specialDividendsNode.Attributes["id"] != null) 
         {
             if (specialDividendsNode.Attributes["id"] != null) 
             {
                 specialDividendsIDRef_ = specialDividendsNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(specialDividendsNode);
                 IDManager.SetID(specialDividendsIDRef_, ob);
             }
             else if (specialDividendsNode.Attributes["href"] != null)
             {
                 specialDividendsIDRef_ = specialDividendsNode.Attributes["href"].Value;
             }
             else
             {
                 specialDividends_ = new XsdTypeBoolean(specialDividendsNode);
             }
         }
         else
         {
             specialDividends_ = new XsdTypeBoolean(specialDividendsNode);
         }
     }
     
 
     XmlNode materialDividendNode = xmlNode.SelectSingleNode("materialDividend");
     
     if (materialDividendNode != null)
     {
         if (materialDividendNode.Attributes["href"] != null || materialDividendNode.Attributes["id"] != null) 
         {
             if (materialDividendNode.Attributes["id"] != null) 
             {
                 materialDividendIDRef_ = materialDividendNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(materialDividendNode);
                 IDManager.SetID(materialDividendIDRef_, ob);
             }
             else if (materialDividendNode.Attributes["href"] != null)
             {
                 materialDividendIDRef_ = materialDividendNode.Attributes["href"].Value;
             }
             else
             {
                 materialDividend_ = new XsdTypeBoolean(materialDividendNode);
             }
         }
         else
         {
             materialDividend_ = new XsdTypeBoolean(materialDividendNode);
         }
     }
     
 
 }
 public Representations(XmlNode xmlNode)
 {
     XmlNode nonRelianceNode = xmlNode.SelectSingleNode("nonReliance");
     
     if (nonRelianceNode != null)
     {
         if (nonRelianceNode.Attributes["href"] != null || nonRelianceNode.Attributes["id"] != null) 
         {
             if (nonRelianceNode.Attributes["id"] != null) 
             {
                 nonRelianceIDRef_ = nonRelianceNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(nonRelianceNode);
                 IDManager.SetID(nonRelianceIDRef_, ob);
             }
             else if (nonRelianceNode.Attributes["href"] != null)
             {
                 nonRelianceIDRef_ = nonRelianceNode.Attributes["href"].Value;
             }
             else
             {
                 nonReliance_ = new XsdTypeBoolean(nonRelianceNode);
             }
         }
         else
         {
             nonReliance_ = new XsdTypeBoolean(nonRelianceNode);
         }
     }
     
 
     XmlNode agreementsRegardingHedgingNode = xmlNode.SelectSingleNode("agreementsRegardingHedging");
     
     if (agreementsRegardingHedgingNode != null)
     {
         if (agreementsRegardingHedgingNode.Attributes["href"] != null || agreementsRegardingHedgingNode.Attributes["id"] != null) 
         {
             if (agreementsRegardingHedgingNode.Attributes["id"] != null) 
             {
                 agreementsRegardingHedgingIDRef_ = agreementsRegardingHedgingNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(agreementsRegardingHedgingNode);
                 IDManager.SetID(agreementsRegardingHedgingIDRef_, ob);
             }
             else if (agreementsRegardingHedgingNode.Attributes["href"] != null)
             {
                 agreementsRegardingHedgingIDRef_ = agreementsRegardingHedgingNode.Attributes["href"].Value;
             }
             else
             {
                 agreementsRegardingHedging_ = new XsdTypeBoolean(agreementsRegardingHedgingNode);
             }
         }
         else
         {
             agreementsRegardingHedging_ = new XsdTypeBoolean(agreementsRegardingHedgingNode);
         }
     }
     
 
     XmlNode indexDisclaimerNode = xmlNode.SelectSingleNode("indexDisclaimer");
     
     if (indexDisclaimerNode != null)
     {
         if (indexDisclaimerNode.Attributes["href"] != null || indexDisclaimerNode.Attributes["id"] != null) 
         {
             if (indexDisclaimerNode.Attributes["id"] != null) 
             {
                 indexDisclaimerIDRef_ = indexDisclaimerNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(indexDisclaimerNode);
                 IDManager.SetID(indexDisclaimerIDRef_, ob);
             }
             else if (indexDisclaimerNode.Attributes["href"] != null)
             {
                 indexDisclaimerIDRef_ = indexDisclaimerNode.Attributes["href"].Value;
             }
             else
             {
                 indexDisclaimer_ = new XsdTypeBoolean(indexDisclaimerNode);
             }
         }
         else
         {
             indexDisclaimer_ = new XsdTypeBoolean(indexDisclaimerNode);
         }
     }
     
 
     XmlNode additionalAcknowledgementsNode = xmlNode.SelectSingleNode("additionalAcknowledgements");
     
     if (additionalAcknowledgementsNode != null)
     {
         if (additionalAcknowledgementsNode.Attributes["href"] != null || additionalAcknowledgementsNode.Attributes["id"] != null) 
         {
             if (additionalAcknowledgementsNode.Attributes["id"] != null) 
             {
                 additionalAcknowledgementsIDRef_ = additionalAcknowledgementsNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(additionalAcknowledgementsNode);
                 IDManager.SetID(additionalAcknowledgementsIDRef_, ob);
             }
             else if (additionalAcknowledgementsNode.Attributes["href"] != null)
             {
                 additionalAcknowledgementsIDRef_ = additionalAcknowledgementsNode.Attributes["href"].Value;
             }
             else
             {
                 additionalAcknowledgements_ = new XsdTypeBoolean(additionalAcknowledgementsNode);
             }
         }
         else
         {
             additionalAcknowledgements_ = new XsdTypeBoolean(additionalAcknowledgementsNode);
         }
     }
     
 
 }
 public OverWriteVariableInfo(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode usingRefVarNameNode = xmlNode.SelectSingleNode("usingRefVarName");
     
     if (usingRefVarNameNode != null)
     {
         if (usingRefVarNameNode.Attributes["href"] != null || usingRefVarNameNode.Attributes["id"] != null) 
         {
             if (usingRefVarNameNode.Attributes["id"] != null) 
             {
                 usingRefVarNameIDRef_ = usingRefVarNameNode.Attributes["id"].Value;
                 XsdTypeToken ob = new XsdTypeToken(usingRefVarNameNode);
                 IDManager.SetID(usingRefVarNameIDRef_, ob);
             }
             else if (usingRefVarNameNode.Attributes["href"] != null)
             {
                 usingRefVarNameIDRef_ = usingRefVarNameNode.Attributes["href"].Value;
             }
             else
             {
                 usingRefVarName_ = new XsdTypeToken(usingRefVarNameNode);
             }
         }
         else
         {
             usingRefVarName_ = new XsdTypeToken(usingRefVarNameNode);
         }
     }
     
 
     XmlNode refInstanceNameNode = xmlNode.SelectSingleNode("refInstanceName");
     
     if (refInstanceNameNode != null)
     {
         if (refInstanceNameNode.Attributes["href"] != null || refInstanceNameNode.Attributes["id"] != null) 
         {
             if (refInstanceNameNode.Attributes["id"] != null) 
             {
                 refInstanceNameIDRef_ = refInstanceNameNode.Attributes["id"].Value;
                 XsdTypeToken ob = new XsdTypeToken(refInstanceNameNode);
                 IDManager.SetID(refInstanceNameIDRef_, ob);
             }
             else if (refInstanceNameNode.Attributes["href"] != null)
             {
                 refInstanceNameIDRef_ = refInstanceNameNode.Attributes["href"].Value;
             }
             else
             {
                 refInstanceName_ = new XsdTypeToken(refInstanceNameNode);
             }
         }
         else
         {
             refInstanceName_ = new XsdTypeToken(refInstanceNameNode);
         }
     }
     
 
     XmlNode saveNode = xmlNode.SelectSingleNode("save");
     
     if (saveNode != null)
     {
         if (saveNode.Attributes["href"] != null || saveNode.Attributes["id"] != null) 
         {
             if (saveNode.Attributes["id"] != null) 
             {
                 saveIDRef_ = saveNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(saveNode);
                 IDManager.SetID(saveIDRef_, ob);
             }
             else if (saveNode.Attributes["href"] != null)
             {
                 saveIDRef_ = saveNode.Attributes["href"].Value;
             }
             else
             {
                 save_ = new XsdTypeBoolean(saveNode);
             }
         }
         else
         {
             save_ = new XsdTypeBoolean(saveNode);
         }
     }
     
 
 }
 public DividendSwapOptionTransactionSupplement(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode equityPremiumNode = xmlNode.SelectSingleNode("equityPremium");
     
     if (equityPremiumNode != null)
     {
         if (equityPremiumNode.Attributes["href"] != null || equityPremiumNode.Attributes["id"] != null) 
         {
             if (equityPremiumNode.Attributes["id"] != null) 
             {
                 equityPremiumIDRef_ = equityPremiumNode.Attributes["id"].Value;
                 EquityPremium ob = new EquityPremium(equityPremiumNode);
                 IDManager.SetID(equityPremiumIDRef_, ob);
             }
             else if (equityPremiumNode.Attributes["href"] != null)
             {
                 equityPremiumIDRef_ = equityPremiumNode.Attributes["href"].Value;
             }
             else
             {
                 equityPremium_ = new EquityPremium(equityPremiumNode);
             }
         }
         else
         {
             equityPremium_ = new EquityPremium(equityPremiumNode);
         }
     }
     
 
     XmlNode equityExerciseNode = xmlNode.SelectSingleNode("equityExercise");
     
     if (equityExerciseNode != null)
     {
         if (equityExerciseNode.Attributes["href"] != null || equityExerciseNode.Attributes["id"] != null) 
         {
             if (equityExerciseNode.Attributes["id"] != null) 
             {
                 equityExerciseIDRef_ = equityExerciseNode.Attributes["id"].Value;
                 EquityExerciseValuationSettlement ob = new EquityExerciseValuationSettlement(equityExerciseNode);
                 IDManager.SetID(equityExerciseIDRef_, ob);
             }
             else if (equityExerciseNode.Attributes["href"] != null)
             {
                 equityExerciseIDRef_ = equityExerciseNode.Attributes["href"].Value;
             }
             else
             {
                 equityExercise_ = new EquityExerciseValuationSettlement(equityExerciseNode);
             }
         }
         else
         {
             equityExercise_ = new EquityExerciseValuationSettlement(equityExerciseNode);
         }
     }
     
 
     XmlNode exchangeLookAlikeNode = xmlNode.SelectSingleNode("exchangeLookAlike");
     
     if (exchangeLookAlikeNode != null)
     {
         if (exchangeLookAlikeNode.Attributes["href"] != null || exchangeLookAlikeNode.Attributes["id"] != null) 
         {
             if (exchangeLookAlikeNode.Attributes["id"] != null) 
             {
                 exchangeLookAlikeIDRef_ = exchangeLookAlikeNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(exchangeLookAlikeNode);
                 IDManager.SetID(exchangeLookAlikeIDRef_, ob);
             }
             else if (exchangeLookAlikeNode.Attributes["href"] != null)
             {
                 exchangeLookAlikeIDRef_ = exchangeLookAlikeNode.Attributes["href"].Value;
             }
             else
             {
                 exchangeLookAlike_ = new XsdTypeBoolean(exchangeLookAlikeNode);
             }
         }
         else
         {
             exchangeLookAlike_ = new XsdTypeBoolean(exchangeLookAlikeNode);
         }
     }
     
 
     XmlNode methodOfAdjustmentNode = xmlNode.SelectSingleNode("methodOfAdjustment");
     
     if (methodOfAdjustmentNode != null)
     {
         if (methodOfAdjustmentNode.Attributes["href"] != null || methodOfAdjustmentNode.Attributes["id"] != null) 
         {
             if (methodOfAdjustmentNode.Attributes["id"] != null) 
             {
                 methodOfAdjustmentIDRef_ = methodOfAdjustmentNode.Attributes["id"].Value;
                 MethodOfAdjustmentEnum ob = new MethodOfAdjustmentEnum(methodOfAdjustmentNode);
                 IDManager.SetID(methodOfAdjustmentIDRef_, ob);
             }
             else if (methodOfAdjustmentNode.Attributes["href"] != null)
             {
                 methodOfAdjustmentIDRef_ = methodOfAdjustmentNode.Attributes["href"].Value;
             }
             else
             {
                 methodOfAdjustment_ = new MethodOfAdjustmentEnum(methodOfAdjustmentNode);
             }
         }
         else
         {
             methodOfAdjustment_ = new MethodOfAdjustmentEnum(methodOfAdjustmentNode);
         }
     }
     
 
     XmlNode optionEntitlementNode = xmlNode.SelectSingleNode("optionEntitlement");
     
     if (optionEntitlementNode != null)
     {
         if (optionEntitlementNode.Attributes["href"] != null || optionEntitlementNode.Attributes["id"] != null) 
         {
             if (optionEntitlementNode.Attributes["id"] != null) 
             {
                 optionEntitlementIDRef_ = optionEntitlementNode.Attributes["id"].Value;
                 PositiveDecimal ob = new PositiveDecimal(optionEntitlementNode);
                 IDManager.SetID(optionEntitlementIDRef_, ob);
             }
             else if (optionEntitlementNode.Attributes["href"] != null)
             {
                 optionEntitlementIDRef_ = optionEntitlementNode.Attributes["href"].Value;
             }
             else
             {
                 optionEntitlement_ = new PositiveDecimal(optionEntitlementNode);
             }
         }
         else
         {
             optionEntitlement_ = new PositiveDecimal(optionEntitlementNode);
         }
     }
     
 
     XmlNode multiplierNode = xmlNode.SelectSingleNode("multiplier");
     
     if (multiplierNode != null)
     {
         if (multiplierNode.Attributes["href"] != null || multiplierNode.Attributes["id"] != null) 
         {
             if (multiplierNode.Attributes["id"] != null) 
             {
                 multiplierIDRef_ = multiplierNode.Attributes["id"].Value;
                 PositiveDecimal ob = new PositiveDecimal(multiplierNode);
                 IDManager.SetID(multiplierIDRef_, ob);
             }
             else if (multiplierNode.Attributes["href"] != null)
             {
                 multiplierIDRef_ = multiplierNode.Attributes["href"].Value;
             }
             else
             {
                 multiplier_ = new PositiveDecimal(multiplierNode);
             }
         }
         else
         {
             multiplier_ = new PositiveDecimal(multiplierNode);
         }
     }
     
 
     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);
         }
     }
     
 
 }
 public ReturnLegValuation(XmlNode xmlNode)
 {
     XmlNode initialPriceNode = xmlNode.SelectSingleNode("initialPrice");
     
     if (initialPriceNode != null)
     {
         if (initialPriceNode.Attributes["href"] != null || initialPriceNode.Attributes["id"] != null) 
         {
             if (initialPriceNode.Attributes["id"] != null) 
             {
                 initialPriceIDRef_ = initialPriceNode.Attributes["id"].Value;
                 ReturnLegValuationPrice ob = new ReturnLegValuationPrice(initialPriceNode);
                 IDManager.SetID(initialPriceIDRef_, ob);
             }
             else if (initialPriceNode.Attributes["href"] != null)
             {
                 initialPriceIDRef_ = initialPriceNode.Attributes["href"].Value;
             }
             else
             {
                 initialPrice_ = new ReturnLegValuationPrice(initialPriceNode);
             }
         }
         else
         {
             initialPrice_ = new ReturnLegValuationPrice(initialPriceNode);
         }
     }
     
 
     XmlNode notionalResetNode = xmlNode.SelectSingleNode("notionalReset");
     
     if (notionalResetNode != null)
     {
         if (notionalResetNode.Attributes["href"] != null || notionalResetNode.Attributes["id"] != null) 
         {
             if (notionalResetNode.Attributes["id"] != null) 
             {
                 notionalResetIDRef_ = notionalResetNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(notionalResetNode);
                 IDManager.SetID(notionalResetIDRef_, ob);
             }
             else if (notionalResetNode.Attributes["href"] != null)
             {
                 notionalResetIDRef_ = notionalResetNode.Attributes["href"].Value;
             }
             else
             {
                 notionalReset_ = new XsdTypeBoolean(notionalResetNode);
             }
         }
         else
         {
             notionalReset_ = new XsdTypeBoolean(notionalResetNode);
         }
     }
     
 
     XmlNode valuationPriceInterimNode = xmlNode.SelectSingleNode("valuationPriceInterim");
     
     if (valuationPriceInterimNode != null)
     {
         if (valuationPriceInterimNode.Attributes["href"] != null || valuationPriceInterimNode.Attributes["id"] != null) 
         {
             if (valuationPriceInterimNode.Attributes["id"] != null) 
             {
                 valuationPriceInterimIDRef_ = valuationPriceInterimNode.Attributes["id"].Value;
                 ReturnLegValuationPrice ob = new ReturnLegValuationPrice(valuationPriceInterimNode);
                 IDManager.SetID(valuationPriceInterimIDRef_, ob);
             }
             else if (valuationPriceInterimNode.Attributes["href"] != null)
             {
                 valuationPriceInterimIDRef_ = valuationPriceInterimNode.Attributes["href"].Value;
             }
             else
             {
                 valuationPriceInterim_ = new ReturnLegValuationPrice(valuationPriceInterimNode);
             }
         }
         else
         {
             valuationPriceInterim_ = new ReturnLegValuationPrice(valuationPriceInterimNode);
         }
     }
     
 
     XmlNode valuationPriceFinalNode = xmlNode.SelectSingleNode("valuationPriceFinal");
     
     if (valuationPriceFinalNode != null)
     {
         if (valuationPriceFinalNode.Attributes["href"] != null || valuationPriceFinalNode.Attributes["id"] != null) 
         {
             if (valuationPriceFinalNode.Attributes["id"] != null) 
             {
                 valuationPriceFinalIDRef_ = valuationPriceFinalNode.Attributes["id"].Value;
                 ReturnLegValuationPrice ob = new ReturnLegValuationPrice(valuationPriceFinalNode);
                 IDManager.SetID(valuationPriceFinalIDRef_, ob);
             }
             else if (valuationPriceFinalNode.Attributes["href"] != null)
             {
                 valuationPriceFinalIDRef_ = valuationPriceFinalNode.Attributes["href"].Value;
             }
             else
             {
                 valuationPriceFinal_ = new ReturnLegValuationPrice(valuationPriceFinalNode);
             }
         }
         else
         {
             valuationPriceFinal_ = new ReturnLegValuationPrice(valuationPriceFinalNode);
         }
     }
     
 
     XmlNode paymentDatesNode = xmlNode.SelectSingleNode("paymentDates");
     
     if (paymentDatesNode != null)
     {
         if (paymentDatesNode.Attributes["href"] != null || paymentDatesNode.Attributes["id"] != null) 
         {
             if (paymentDatesNode.Attributes["id"] != null) 
             {
                 paymentDatesIDRef_ = paymentDatesNode.Attributes["id"].Value;
                 ReturnSwapPaymentDates ob = new ReturnSwapPaymentDates(paymentDatesNode);
                 IDManager.SetID(paymentDatesIDRef_, ob);
             }
             else if (paymentDatesNode.Attributes["href"] != null)
             {
                 paymentDatesIDRef_ = paymentDatesNode.Attributes["href"].Value;
             }
             else
             {
                 paymentDates_ = new ReturnSwapPaymentDates(paymentDatesNode);
             }
         }
         else
         {
             paymentDates_ = new ReturnSwapPaymentDates(paymentDatesNode);
         }
     }
     
 
     XmlNode exchangeTradedContractNearestNode = xmlNode.SelectSingleNode("exchangeTradedContractNearest");
     
     if (exchangeTradedContractNearestNode != null)
     {
         if (exchangeTradedContractNearestNode.Attributes["href"] != null || exchangeTradedContractNearestNode.Attributes["id"] != null) 
         {
             if (exchangeTradedContractNearestNode.Attributes["id"] != null) 
             {
                 exchangeTradedContractNearestIDRef_ = exchangeTradedContractNearestNode.Attributes["id"].Value;
                 ExchangeTradedContract ob = new ExchangeTradedContract(exchangeTradedContractNearestNode);
                 IDManager.SetID(exchangeTradedContractNearestIDRef_, ob);
             }
             else if (exchangeTradedContractNearestNode.Attributes["href"] != null)
             {
                 exchangeTradedContractNearestIDRef_ = exchangeTradedContractNearestNode.Attributes["href"].Value;
             }
             else
             {
                 exchangeTradedContractNearest_ = new ExchangeTradedContract(exchangeTradedContractNearestNode);
             }
         }
         else
         {
             exchangeTradedContractNearest_ = new ExchangeTradedContract(exchangeTradedContractNearestNode);
         }
     }
     
 
 }
 public FeeLeg(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode initialPaymentNode = xmlNode.SelectSingleNode("initialPayment");
     
     if (initialPaymentNode != null)
     {
         if (initialPaymentNode.Attributes["href"] != null || initialPaymentNode.Attributes["id"] != null) 
         {
             if (initialPaymentNode.Attributes["id"] != null) 
             {
                 initialPaymentIDRef_ = initialPaymentNode.Attributes["id"].Value;
                 InitialPayment ob = new InitialPayment(initialPaymentNode);
                 IDManager.SetID(initialPaymentIDRef_, ob);
             }
             else if (initialPaymentNode.Attributes["href"] != null)
             {
                 initialPaymentIDRef_ = initialPaymentNode.Attributes["href"].Value;
             }
             else
             {
                 initialPayment_ = new InitialPayment(initialPaymentNode);
             }
         }
         else
         {
             initialPayment_ = new InitialPayment(initialPaymentNode);
         }
     }
     
 
     XmlNodeList singlePaymentNodeList = xmlNode.SelectNodes("singlePayment");
     
     if (singlePaymentNodeList != null)
     {
         this.singlePayment_ = new List<SinglePayment>();
         foreach (XmlNode item in singlePaymentNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     singlePaymentIDRef_ = item.Attributes["id"].Value;
                     singlePayment_.Add(new SinglePayment(item));
                     IDManager.SetID(singlePaymentIDRef_, singlePayment_[singlePayment_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     singlePaymentIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 singlePayment_.Add(new SinglePayment(item));
                 }
             }
             else
             {
                 singlePayment_.Add(new SinglePayment(item));
             }
         }
     }
     
 
     XmlNode periodicPaymentNode = xmlNode.SelectSingleNode("periodicPayment");
     
     if (periodicPaymentNode != null)
     {
         if (periodicPaymentNode.Attributes["href"] != null || periodicPaymentNode.Attributes["id"] != null) 
         {
             if (periodicPaymentNode.Attributes["id"] != null) 
             {
                 periodicPaymentIDRef_ = periodicPaymentNode.Attributes["id"].Value;
                 PeriodicPayment ob = new PeriodicPayment(periodicPaymentNode);
                 IDManager.SetID(periodicPaymentIDRef_, ob);
             }
             else if (periodicPaymentNode.Attributes["href"] != null)
             {
                 periodicPaymentIDRef_ = periodicPaymentNode.Attributes["href"].Value;
             }
             else
             {
                 periodicPayment_ = new PeriodicPayment(periodicPaymentNode);
             }
         }
         else
         {
             periodicPayment_ = new PeriodicPayment(periodicPaymentNode);
         }
     }
     
 
     XmlNode marketFixedRateNode = xmlNode.SelectSingleNode("marketFixedRate");
     
     if (marketFixedRateNode != null)
     {
         if (marketFixedRateNode.Attributes["href"] != null || marketFixedRateNode.Attributes["id"] != null) 
         {
             if (marketFixedRateNode.Attributes["id"] != null) 
             {
                 marketFixedRateIDRef_ = marketFixedRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(marketFixedRateNode);
                 IDManager.SetID(marketFixedRateIDRef_, ob);
             }
             else if (marketFixedRateNode.Attributes["href"] != null)
             {
                 marketFixedRateIDRef_ = marketFixedRateNode.Attributes["href"].Value;
             }
             else
             {
                 marketFixedRate_ = new XsdTypeDecimal(marketFixedRateNode);
             }
         }
         else
         {
             marketFixedRate_ = new XsdTypeDecimal(marketFixedRateNode);
         }
     }
     
 
     XmlNode paymentDelayNode = xmlNode.SelectSingleNode("paymentDelay");
     
     if (paymentDelayNode != null)
     {
         if (paymentDelayNode.Attributes["href"] != null || paymentDelayNode.Attributes["id"] != null) 
         {
             if (paymentDelayNode.Attributes["id"] != null) 
             {
                 paymentDelayIDRef_ = paymentDelayNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(paymentDelayNode);
                 IDManager.SetID(paymentDelayIDRef_, ob);
             }
             else if (paymentDelayNode.Attributes["href"] != null)
             {
                 paymentDelayIDRef_ = paymentDelayNode.Attributes["href"].Value;
             }
             else
             {
                 paymentDelay_ = new XsdTypeBoolean(paymentDelayNode);
             }
         }
         else
         {
             paymentDelay_ = new XsdTypeBoolean(paymentDelayNode);
         }
     }
     
 
     XmlNode initialPointsNode = xmlNode.SelectSingleNode("initialPoints");
     
     if (initialPointsNode != null)
     {
         if (initialPointsNode.Attributes["href"] != null || initialPointsNode.Attributes["id"] != null) 
         {
             if (initialPointsNode.Attributes["id"] != null) 
             {
                 initialPointsIDRef_ = initialPointsNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(initialPointsNode);
                 IDManager.SetID(initialPointsIDRef_, ob);
             }
             else if (initialPointsNode.Attributes["href"] != null)
             {
                 initialPointsIDRef_ = initialPointsNode.Attributes["href"].Value;
             }
             else
             {
                 initialPoints_ = new XsdTypeDecimal(initialPointsNode);
             }
         }
         else
         {
             initialPoints_ = new XsdTypeDecimal(initialPointsNode);
         }
     }
     
 
     XmlNode quotationStyleNode = xmlNode.SelectSingleNode("quotationStyle");
     
     if (quotationStyleNode != null)
     {
         if (quotationStyleNode.Attributes["href"] != null || quotationStyleNode.Attributes["id"] != null) 
         {
             if (quotationStyleNode.Attributes["id"] != null) 
             {
                 quotationStyleIDRef_ = quotationStyleNode.Attributes["id"].Value;
                 QuotationStyleEnum ob = new QuotationStyleEnum(quotationStyleNode);
                 IDManager.SetID(quotationStyleIDRef_, ob);
             }
             else if (quotationStyleNode.Attributes["href"] != null)
             {
                 quotationStyleIDRef_ = quotationStyleNode.Attributes["href"].Value;
             }
             else
             {
                 quotationStyle_ = new QuotationStyleEnum(quotationStyleNode);
             }
         }
         else
         {
             quotationStyle_ = new QuotationStyleEnum(quotationStyleNode);
         }
     }
     
 
 }
 public SimpleRangeConstReturnTrigger(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode dateOrderNode = xmlNode.SelectSingleNode("dateOrder");
     
     if (dateOrderNode != null)
     {
         if (dateOrderNode.Attributes["href"] != null || dateOrderNode.Attributes["id"] != null) 
         {
             if (dateOrderNode.Attributes["id"] != null) 
             {
                 dateOrderIDRef_ = dateOrderNode.Attributes["id"].Value;
                 XsdTypeInteger ob = new XsdTypeInteger(dateOrderNode);
                 IDManager.SetID(dateOrderIDRef_, ob);
             }
             else if (dateOrderNode.Attributes["href"] != null)
             {
                 dateOrderIDRef_ = dateOrderNode.Attributes["href"].Value;
             }
             else
             {
                 dateOrder_ = new XsdTypeInteger(dateOrderNode);
             }
         }
         else
         {
             dateOrder_ = new XsdTypeInteger(dateOrderNode);
         }
     }
     
 
     XmlNode simpleRangeEventCalNode = xmlNode.SelectSingleNode("simpleRangeEventCal");
     
     if (simpleRangeEventCalNode != null)
     {
         if (simpleRangeEventCalNode.Attributes["href"] != null || simpleRangeEventCalNode.Attributes["id"] != null) 
         {
             if (simpleRangeEventCalNode.Attributes["id"] != null) 
             {
                 simpleRangeEventCalIDRef_ = simpleRangeEventCalNode.Attributes["id"].Value;
                 SimpleRangeEventCal ob = new SimpleRangeEventCal(simpleRangeEventCalNode);
                 IDManager.SetID(simpleRangeEventCalIDRef_, ob);
             }
             else if (simpleRangeEventCalNode.Attributes["href"] != null)
             {
                 simpleRangeEventCalIDRef_ = simpleRangeEventCalNode.Attributes["href"].Value;
             }
             else
             {
                 simpleRangeEventCal_ = new SimpleRangeEventCal(simpleRangeEventCalNode);
             }
         }
         else
         {
             simpleRangeEventCal_ = new SimpleRangeEventCal(simpleRangeEventCalNode);
         }
     }
     
 
     XmlNode payoffDateInfoNode = xmlNode.SelectSingleNode("payoffDateInfo");
     
     if (payoffDateInfoNode != null)
     {
         if (payoffDateInfoNode.Attributes["href"] != null || payoffDateInfoNode.Attributes["id"] != null) 
         {
             if (payoffDateInfoNode.Attributes["id"] != null) 
             {
                 payoffDateInfoIDRef_ = payoffDateInfoNode.Attributes["id"].Value;
                 PayoffDateInfo ob = new PayoffDateInfo(payoffDateInfoNode);
                 IDManager.SetID(payoffDateInfoIDRef_, ob);
             }
             else if (payoffDateInfoNode.Attributes["href"] != null)
             {
                 payoffDateInfoIDRef_ = payoffDateInfoNode.Attributes["href"].Value;
             }
             else
             {
                 payoffDateInfo_ = new PayoffDateInfo(payoffDateInfoNode);
             }
         }
         else
         {
             payoffDateInfo_ = new PayoffDateInfo(payoffDateInfoNode);
         }
     }
     
 
     XmlNode constReturnNode = xmlNode.SelectSingleNode("constReturn");
     
     if (constReturnNode != null)
     {
         if (constReturnNode.Attributes["href"] != null || constReturnNode.Attributes["id"] != null) 
         {
             if (constReturnNode.Attributes["id"] != null) 
             {
                 constReturnIDRef_ = constReturnNode.Attributes["id"].Value;
                 XsdTypeDouble ob = new XsdTypeDouble(constReturnNode);
                 IDManager.SetID(constReturnIDRef_, ob);
             }
             else if (constReturnNode.Attributes["href"] != null)
             {
                 constReturnIDRef_ = constReturnNode.Attributes["href"].Value;
             }
             else
             {
                 constReturn_ = new XsdTypeDouble(constReturnNode);
             }
         }
         else
         {
             constReturn_ = new XsdTypeDouble(constReturnNode);
         }
     }
     
 
     XmlNode averageDaysNode = xmlNode.SelectSingleNode("averageDays");
     
     if (averageDaysNode != null)
     {
         if (averageDaysNode.Attributes["href"] != null || averageDaysNode.Attributes["id"] != null) 
         {
             if (averageDaysNode.Attributes["id"] != null) 
             {
                 averageDaysIDRef_ = averageDaysNode.Attributes["id"].Value;
                 XsdTypeInteger ob = new XsdTypeInteger(averageDaysNode);
                 IDManager.SetID(averageDaysIDRef_, ob);
             }
             else if (averageDaysNode.Attributes["href"] != null)
             {
                 averageDaysIDRef_ = averageDaysNode.Attributes["href"].Value;
             }
             else
             {
                 averageDays_ = new XsdTypeInteger(averageDaysNode);
             }
         }
         else
         {
             averageDays_ = new XsdTypeInteger(averageDaysNode);
         }
     }
     
 
     XmlNode isExpiredNode = xmlNode.SelectSingleNode("isExpired");
     
     if (isExpiredNode != null)
     {
         if (isExpiredNode.Attributes["href"] != null || isExpiredNode.Attributes["id"] != null) 
         {
             if (isExpiredNode.Attributes["id"] != null) 
             {
                 isExpiredIDRef_ = isExpiredNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(isExpiredNode);
                 IDManager.SetID(isExpiredIDRef_, ob);
             }
             else if (isExpiredNode.Attributes["href"] != null)
             {
                 isExpiredIDRef_ = isExpiredNode.Attributes["href"].Value;
             }
             else
             {
                 isExpired_ = new XsdTypeBoolean(isExpiredNode);
             }
         }
         else
         {
             isExpired_ = new XsdTypeBoolean(isExpiredNode);
         }
     }
     
 
 }