public ValuationPostponement(XmlNode xmlNode)
 {
     XmlNode maximumDaysOfPostponementNode = xmlNode.SelectSingleNode("maximumDaysOfPostponement");
     
     if (maximumDaysOfPostponementNode != null)
     {
         if (maximumDaysOfPostponementNode.Attributes["href"] != null || maximumDaysOfPostponementNode.Attributes["id"] != null) 
         {
             if (maximumDaysOfPostponementNode.Attributes["id"] != null) 
             {
                 maximumDaysOfPostponementIDRef_ = maximumDaysOfPostponementNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
                 IDManager.SetID(maximumDaysOfPostponementIDRef_, ob);
             }
             else if (maximumDaysOfPostponementNode.Attributes["href"] != null)
             {
                 maximumDaysOfPostponementIDRef_ = maximumDaysOfPostponementNode.Attributes["href"].Value;
             }
             else
             {
                 maximumDaysOfPostponement_ = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
             }
         }
         else
         {
             maximumDaysOfPostponement_ = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
         }
     }
     
 
 }
        public ReportIdentification(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList numberOfSectionsNodeList = xmlNode.SelectNodes("numberOfSections");

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

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


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

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

            foreach (XmlNode item in submissionsCompleteNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        submissionsCompleteIDRef = item.Attributes["id"].Name;
                        XsdTypeBoolean ob = XsdTypeBoolean();
                        IDManager.SetID(submissionsCompleteIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        submissionsCompleteIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        submissionsComplete = new XsdTypeBoolean(item);
                    }
                }
            }
        }
 public MultipleValuationDates(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode businessDaysThereafterNode = xmlNode.SelectSingleNode("businessDaysThereafter");
     
     if (businessDaysThereafterNode != null)
     {
         if (businessDaysThereafterNode.Attributes["href"] != null || businessDaysThereafterNode.Attributes["id"] != null) 
         {
             if (businessDaysThereafterNode.Attributes["id"] != null) 
             {
                 businessDaysThereafterIDRef_ = businessDaysThereafterNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(businessDaysThereafterNode);
                 IDManager.SetID(businessDaysThereafterIDRef_, ob);
             }
             else if (businessDaysThereafterNode.Attributes["href"] != null)
             {
                 businessDaysThereafterIDRef_ = businessDaysThereafterNode.Attributes["href"].Value;
             }
             else
             {
                 businessDaysThereafter_ = new XsdTypePositiveInteger(businessDaysThereafterNode);
             }
         }
         else
         {
             businessDaysThereafter_ = new XsdTypePositiveInteger(businessDaysThereafterNode);
         }
     }
     
 
     XmlNode numberValuationDatesNode = xmlNode.SelectSingleNode("numberValuationDates");
     
     if (numberValuationDatesNode != null)
     {
         if (numberValuationDatesNode.Attributes["href"] != null || numberValuationDatesNode.Attributes["id"] != null) 
         {
             if (numberValuationDatesNode.Attributes["id"] != null) 
             {
                 numberValuationDatesIDRef_ = numberValuationDatesNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberValuationDatesNode);
                 IDManager.SetID(numberValuationDatesIDRef_, ob);
             }
             else if (numberValuationDatesNode.Attributes["href"] != null)
             {
                 numberValuationDatesIDRef_ = numberValuationDatesNode.Attributes["href"].Value;
             }
             else
             {
                 numberValuationDates_ = new XsdTypePositiveInteger(numberValuationDatesNode);
             }
         }
         else
         {
             numberValuationDates_ = new XsdTypePositiveInteger(numberValuationDatesNode);
         }
     }
     
 
 }
        public PortfolioConstituentReference(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);
                }
            }
        }
        public FutureValueAmount(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList calculationPeriodNumberOfDaysNodeList = xmlNode.SelectNodes("calculationPeriodNumberOfDays");

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

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


            XmlNodeList valueDateNodeList = xmlNode.SelectNodes("valueDate");

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

            foreach (XmlNode item in valueDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valueDateIDRef = item.Attributes["id"].Name;
                        XsdTypeDate ob = XsdTypeDate();
                        IDManager.SetID(valueDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valueDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valueDate = new XsdTypeDate(item);
                    }
                }
            }
        }
 public PortfolioConstituentReference(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);
         }
     }
     
 
 }
Beispiel #7
0
        public PortfolioConstituentReference(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);
                    }
                }
            }
        }
 public FutureValueAmount(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode calculationPeriodNumberOfDaysNode = xmlNode.SelectSingleNode("calculationPeriodNumberOfDays");
     
     if (calculationPeriodNumberOfDaysNode != null)
     {
         if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null || calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
         {
             if (calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef_, ob);
             }
             else if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null)
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
             }
         }
         else
         {
             calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
         }
     }
     
 
     XmlNode valueDateNode = xmlNode.SelectSingleNode("valueDate");
     
     if (valueDateNode != null)
     {
         if (valueDateNode.Attributes["href"] != null || valueDateNode.Attributes["id"] != null) 
         {
             if (valueDateNode.Attributes["id"] != null) 
             {
                 valueDateIDRef_ = valueDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(valueDateNode);
                 IDManager.SetID(valueDateIDRef_, ob);
             }
             else if (valueDateNode.Attributes["href"] != null)
             {
                 valueDateIDRef_ = valueDateNode.Attributes["href"].Value;
             }
             else
             {
                 valueDate_ = new XsdTypeDate(valueDateNode);
             }
         }
         else
         {
             valueDate_ = new XsdTypeDate(valueDateNode);
         }
     }
     
 
 }
Beispiel #9
0
        public MultipleValuationDates(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList businessDaysThereafterNodeList = xmlNode.SelectNodes("businessDaysThereafter");

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

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


            XmlNodeList numberValuationDatesNodeList = xmlNode.SelectNodes("numberValuationDates");

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

            foreach (XmlNode item in numberValuationDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        numberValuationDatesIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(numberValuationDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        numberValuationDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        numberValuationDates = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
 public PortfolioReference(XmlNode xmlNode)
 : base(xmlNode)
 {
     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 RelativeDates(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode periodSkipNode = xmlNode.SelectSingleNode("periodSkip");
     
     if (periodSkipNode != null)
     {
         if (periodSkipNode.Attributes["href"] != null || periodSkipNode.Attributes["id"] != null) 
         {
             if (periodSkipNode.Attributes["id"] != null) 
             {
                 periodSkipIDRef_ = periodSkipNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(periodSkipNode);
                 IDManager.SetID(periodSkipIDRef_, ob);
             }
             else if (periodSkipNode.Attributes["href"] != null)
             {
                 periodSkipIDRef_ = periodSkipNode.Attributes["href"].Value;
             }
             else
             {
                 periodSkip_ = new XsdTypePositiveInteger(periodSkipNode);
             }
         }
         else
         {
             periodSkip_ = new XsdTypePositiveInteger(periodSkipNode);
         }
     }
     
 
     XmlNode scheduleBoundsNode = xmlNode.SelectSingleNode("scheduleBounds");
     
     if (scheduleBoundsNode != null)
     {
         if (scheduleBoundsNode.Attributes["href"] != null || scheduleBoundsNode.Attributes["id"] != null) 
         {
             if (scheduleBoundsNode.Attributes["id"] != null) 
             {
                 scheduleBoundsIDRef_ = scheduleBoundsNode.Attributes["id"].Value;
                 DateRange ob = new DateRange(scheduleBoundsNode);
                 IDManager.SetID(scheduleBoundsIDRef_, ob);
             }
             else if (scheduleBoundsNode.Attributes["href"] != null)
             {
                 scheduleBoundsIDRef_ = scheduleBoundsNode.Attributes["href"].Value;
             }
             else
             {
                 scheduleBounds_ = new DateRange(scheduleBoundsNode);
             }
         }
         else
         {
             scheduleBounds_ = new DateRange(scheduleBoundsNode);
         }
     }
     
 
 }
 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 ValuationPostponement(XmlNode xmlNode)
        {
            XmlNode maximumDaysOfPostponementNode = xmlNode.SelectSingleNode("maximumDaysOfPostponement");

            if (maximumDaysOfPostponementNode != null)
            {
                if (maximumDaysOfPostponementNode.Attributes["href"] != null || maximumDaysOfPostponementNode.Attributes["id"] != null)
                {
                    if (maximumDaysOfPostponementNode.Attributes["id"] != null)
                    {
                        maximumDaysOfPostponementIDRef_ = maximumDaysOfPostponementNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
                        IDManager.SetID(maximumDaysOfPostponementIDRef_, ob);
                    }
                    else if (maximumDaysOfPostponementNode.Attributes["href"] != null)
                    {
                        maximumDaysOfPostponementIDRef_ = maximumDaysOfPostponementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumDaysOfPostponement_ = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
                    }
                }
                else
                {
                    maximumDaysOfPostponement_ = new XsdTypePositiveInteger(maximumDaysOfPostponementNode);
                }
            }
        }
Beispiel #14
0
        public ValuationPostponement(XmlNode xmlNode)
        {
            XmlNodeList maximumDaysOfPostponementNodeList = xmlNode.SelectNodes("maximumDaysOfPostponement");

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

            foreach (XmlNode item in maximumDaysOfPostponementNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        maximumDaysOfPostponementIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(maximumDaysOfPostponementIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        maximumDaysOfPostponementIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        maximumDaysOfPostponement = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
        public RelativeDates(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList periodSkipNodeList = xmlNode.SelectNodes("periodSkip");

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

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


            XmlNodeList scheduleBoundsNodeList = xmlNode.SelectNodes("scheduleBounds");

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

            foreach (XmlNode item in scheduleBoundsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        scheduleBoundsIDRef = item.Attributes["id"].Name;
                        DateRange ob = DateRange();
                        IDManager.SetID(scheduleBoundsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        scheduleBoundsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        scheduleBounds = new DateRange(item);
                    }
                }
            }
        }
        public SequencedDisruptionFallback(XmlNode xmlNode)
        {
            XmlNodeList fallbackNodeList = xmlNode.SelectNodes("fallback");

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

            foreach (XmlNode item in fallbackNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fallbackIDRef = item.Attributes["id"].Name;
                        DisruptionFallback ob = DisruptionFallback();
                        IDManager.SetID(fallbackIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fallbackIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fallback = new DisruptionFallback(item);
                    }
                }
            }


            XmlNodeList sequenceNodeList = xmlNode.SelectNodes("sequence");

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

            foreach (XmlNode item in sequenceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        sequenceIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(sequenceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        sequenceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        sequence = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
 public Frequency(XmlNode xmlNode)
 {
     XmlNode periodMultiplierNode = xmlNode.SelectSingleNode("periodMultiplier");
     
     if (periodMultiplierNode != null)
     {
         if (periodMultiplierNode.Attributes["href"] != null || periodMultiplierNode.Attributes["id"] != null) 
         {
             if (periodMultiplierNode.Attributes["id"] != null) 
             {
                 periodMultiplierIDRef_ = periodMultiplierNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(periodMultiplierNode);
                 IDManager.SetID(periodMultiplierIDRef_, ob);
             }
             else if (periodMultiplierNode.Attributes["href"] != null)
             {
                 periodMultiplierIDRef_ = periodMultiplierNode.Attributes["href"].Value;
             }
             else
             {
                 periodMultiplier_ = new XsdTypePositiveInteger(periodMultiplierNode);
             }
         }
         else
         {
             periodMultiplier_ = new XsdTypePositiveInteger(periodMultiplierNode);
         }
     }
     
 
     XmlNode periodNode = xmlNode.SelectSingleNode("period");
     
     if (periodNode != null)
     {
         if (periodNode.Attributes["href"] != null || periodNode.Attributes["id"] != null) 
         {
             if (periodNode.Attributes["id"] != null) 
             {
                 periodIDRef_ = periodNode.Attributes["id"].Value;
                 PeriodExtendedEnum ob = new PeriodExtendedEnum(periodNode);
                 IDManager.SetID(periodIDRef_, ob);
             }
             else if (periodNode.Attributes["href"] != null)
             {
                 periodIDRef_ = periodNode.Attributes["href"].Value;
             }
             else
             {
                 period_ = new PeriodExtendedEnum(periodNode);
             }
         }
         else
         {
             period_ = new PeriodExtendedEnum(periodNode);
         }
     }
     
 
 }
 public SequencedDisruptionFallback(XmlNode xmlNode)
 {
     XmlNode fallbackNode = xmlNode.SelectSingleNode("fallback");
     
     if (fallbackNode != null)
     {
         if (fallbackNode.Attributes["href"] != null || fallbackNode.Attributes["id"] != null) 
         {
             if (fallbackNode.Attributes["id"] != null) 
             {
                 fallbackIDRef_ = fallbackNode.Attributes["id"].Value;
                 DisruptionFallback ob = new DisruptionFallback(fallbackNode);
                 IDManager.SetID(fallbackIDRef_, ob);
             }
             else if (fallbackNode.Attributes["href"] != null)
             {
                 fallbackIDRef_ = fallbackNode.Attributes["href"].Value;
             }
             else
             {
                 fallback_ = new DisruptionFallback(fallbackNode);
             }
         }
         else
         {
             fallback_ = new DisruptionFallback(fallbackNode);
         }
     }
     
 
     XmlNode sequenceNode = xmlNode.SelectSingleNode("sequence");
     
     if (sequenceNode != null)
     {
         if (sequenceNode.Attributes["href"] != null || sequenceNode.Attributes["id"] != null) 
         {
             if (sequenceNode.Attributes["id"] != null) 
             {
                 sequenceIDRef_ = sequenceNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sequenceNode);
                 IDManager.SetID(sequenceIDRef_, ob);
             }
             else if (sequenceNode.Attributes["href"] != null)
             {
                 sequenceIDRef_ = sequenceNode.Attributes["href"].Value;
             }
             else
             {
                 sequence_ = new XsdTypePositiveInteger(sequenceNode);
             }
         }
         else
         {
             sequence_ = new XsdTypePositiveInteger(sequenceNode);
         }
     }
     
 
 }
Beispiel #19
0
        public Frequency(XmlNode xmlNode)
        {
            XmlNodeList periodMultiplierNodeList = xmlNode.SelectNodes("periodMultiplier");

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

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


            XmlNodeList periodNodeList = xmlNode.SelectNodes("period");

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

            foreach (XmlNode item in periodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        periodIDRef = item.Attributes["id"].Name;
                        PeriodExtendedEnum ob = PeriodExtendedEnum();
                        IDManager.SetID(periodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        periodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        period = new PeriodExtendedEnum(item);
                    }
                }
            }
        }
 public DenominatorTerm(XmlNode xmlNode)
 {
     XmlNode weightedPartialNode = xmlNode.SelectSingleNode("weightedPartial");
     
     if (weightedPartialNode != null)
     {
         if (weightedPartialNode.Attributes["href"] != null || weightedPartialNode.Attributes["id"] != null) 
         {
             if (weightedPartialNode.Attributes["id"] != null) 
             {
                 weightedPartialIDRef_ = weightedPartialNode.Attributes["id"].Value;
                 WeightedPartialDerivative ob = new WeightedPartialDerivative(weightedPartialNode);
                 IDManager.SetID(weightedPartialIDRef_, ob);
             }
             else if (weightedPartialNode.Attributes["href"] != null)
             {
                 weightedPartialIDRef_ = weightedPartialNode.Attributes["href"].Value;
             }
             else
             {
                 weightedPartial_ = new WeightedPartialDerivative(weightedPartialNode);
             }
         }
         else
         {
             weightedPartial_ = new WeightedPartialDerivative(weightedPartialNode);
         }
     }
     
 
     XmlNode powerNode = xmlNode.SelectSingleNode("power");
     
     if (powerNode != null)
     {
         if (powerNode.Attributes["href"] != null || powerNode.Attributes["id"] != null) 
         {
             if (powerNode.Attributes["id"] != null) 
             {
                 powerIDRef_ = powerNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(powerNode);
                 IDManager.SetID(powerIDRef_, ob);
             }
             else if (powerNode.Attributes["href"] != null)
             {
                 powerIDRef_ = powerNode.Attributes["href"].Value;
             }
             else
             {
                 power_ = new XsdTypePositiveInteger(powerNode);
             }
         }
         else
         {
             power_ = new XsdTypePositiveInteger(powerNode);
         }
     }
     
 
 }
 public ReportSectionIdentification(XmlNode xmlNode)
 {
     XmlNode reportIdNode = xmlNode.SelectSingleNode("reportId");
     
     if (reportIdNode != null)
     {
         if (reportIdNode.Attributes["href"] != null || reportIdNode.Attributes["id"] != null) 
         {
             if (reportIdNode.Attributes["id"] != null) 
             {
                 reportIdIDRef_ = reportIdNode.Attributes["id"].Value;
                 ReportId ob = new ReportId(reportIdNode);
                 IDManager.SetID(reportIdIDRef_, ob);
             }
             else if (reportIdNode.Attributes["href"] != null)
             {
                 reportIdIDRef_ = reportIdNode.Attributes["href"].Value;
             }
             else
             {
                 reportId_ = new ReportId(reportIdNode);
             }
         }
         else
         {
             reportId_ = new ReportId(reportIdNode);
         }
     }
     
 
     XmlNode sectionNumberNode = xmlNode.SelectSingleNode("sectionNumber");
     
     if (sectionNumberNode != null)
     {
         if (sectionNumberNode.Attributes["href"] != null || sectionNumberNode.Attributes["id"] != null) 
         {
             if (sectionNumberNode.Attributes["id"] != null) 
             {
                 sectionNumberIDRef_ = sectionNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sectionNumberNode);
                 IDManager.SetID(sectionNumberIDRef_, ob);
             }
             else if (sectionNumberNode.Attributes["href"] != null)
             {
                 sectionNumberIDRef_ = sectionNumberNode.Attributes["href"].Value;
             }
             else
             {
                 sectionNumber_ = new XsdTypePositiveInteger(sectionNumberNode);
             }
         }
         else
         {
             sectionNumber_ = new XsdTypePositiveInteger(sectionNumberNode);
         }
     }
     
 
 }
        public ReportSectionIdentification(XmlNode xmlNode)
        {
            XmlNodeList reportIdNodeList = xmlNode.SelectNodes("reportId");

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

            foreach (XmlNode item in reportIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        reportIdIDRef = item.Attributes["id"].Name;
                        ReportId ob = ReportId();
                        IDManager.SetID(reportIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        reportIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        reportId = new ReportId(item);
                    }
                }
            }


            XmlNodeList sectionNumberNodeList = xmlNode.SelectNodes("sectionNumber");

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

            foreach (XmlNode item in sectionNumberNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        sectionNumberIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(sectionNumberIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        sectionNumberIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        sectionNumber = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
Beispiel #23
0
        public DenominatorTerm(XmlNode xmlNode)
        {
            XmlNodeList weightedPartialNodeList = xmlNode.SelectNodes("weightedPartial");

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

            foreach (XmlNode item in weightedPartialNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        weightedPartialIDRef = item.Attributes["id"].Name;
                        WeightedPartialDerivative ob = WeightedPartialDerivative();
                        IDManager.SetID(weightedPartialIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        weightedPartialIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        weightedPartial = new WeightedPartialDerivative(item);
                    }
                }
            }


            XmlNodeList powerNodeList = xmlNode.SelectNodes("power");

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

            foreach (XmlNode item in powerNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        powerIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(powerIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        powerIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        power = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
        public 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);
                }
            }
        }
Beispiel #25
0
        public MultipleValuationDates(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode businessDaysThereafterNode = xmlNode.SelectSingleNode("businessDaysThereafter");

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


            XmlNode numberValuationDatesNode = xmlNode.SelectSingleNode("numberValuationDates");

            if (numberValuationDatesNode != null)
            {
                if (numberValuationDatesNode.Attributes["href"] != null || numberValuationDatesNode.Attributes["id"] != null)
                {
                    if (numberValuationDatesNode.Attributes["id"] != null)
                    {
                        numberValuationDatesIDRef_ = numberValuationDatesNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberValuationDatesNode);
                        IDManager.SetID(numberValuationDatesIDRef_, ob);
                    }
                    else if (numberValuationDatesNode.Attributes["href"] != null)
                    {
                        numberValuationDatesIDRef_ = numberValuationDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        numberValuationDates_ = new XsdTypePositiveInteger(numberValuationDatesNode);
                    }
                }
                else
                {
                    numberValuationDates_ = new XsdTypePositiveInteger(numberValuationDatesNode);
                }
            }
        }
Beispiel #26
0
        public FutureValueAmount(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode calculationPeriodNumberOfDaysNode = xmlNode.SelectSingleNode("calculationPeriodNumberOfDays");

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


            XmlNode valueDateNode = xmlNode.SelectSingleNode("valueDate");

            if (valueDateNode != null)
            {
                if (valueDateNode.Attributes["href"] != null || valueDateNode.Attributes["id"] != null)
                {
                    if (valueDateNode.Attributes["id"] != null)
                    {
                        valueDateIDRef_ = valueDateNode.Attributes["id"].Value;
                        XsdTypeDate ob = new XsdTypeDate(valueDateNode);
                        IDManager.SetID(valueDateIDRef_, ob);
                    }
                    else if (valueDateNode.Attributes["href"] != null)
                    {
                        valueDateIDRef_ = valueDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valueDate_ = new XsdTypeDate(valueDateNode);
                    }
                }
                else
                {
                    valueDate_ = new XsdTypeDate(valueDateNode);
                }
            }
        }
Beispiel #27
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 RelativeDates(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode periodSkipNode = xmlNode.SelectSingleNode("periodSkip");

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


            XmlNode scheduleBoundsNode = xmlNode.SelectSingleNode("scheduleBounds");

            if (scheduleBoundsNode != null)
            {
                if (scheduleBoundsNode.Attributes["href"] != null || scheduleBoundsNode.Attributes["id"] != null)
                {
                    if (scheduleBoundsNode.Attributes["id"] != null)
                    {
                        scheduleBoundsIDRef_ = scheduleBoundsNode.Attributes["id"].Value;
                        DateRange ob = new DateRange(scheduleBoundsNode);
                        IDManager.SetID(scheduleBoundsIDRef_, ob);
                    }
                    else if (scheduleBoundsNode.Attributes["href"] != null)
                    {
                        scheduleBoundsIDRef_ = scheduleBoundsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        scheduleBounds_ = new DateRange(scheduleBoundsNode);
                    }
                }
                else
                {
                    scheduleBounds_ = new DateRange(scheduleBoundsNode);
                }
            }
        }
        public ReportSectionIdentification(XmlNode xmlNode)
        {
            XmlNode reportIdNode = xmlNode.SelectSingleNode("reportId");

            if (reportIdNode != null)
            {
                if (reportIdNode.Attributes["href"] != null || reportIdNode.Attributes["id"] != null)
                {
                    if (reportIdNode.Attributes["id"] != null)
                    {
                        reportIdIDRef_ = reportIdNode.Attributes["id"].Value;
                        ReportId ob = new ReportId(reportIdNode);
                        IDManager.SetID(reportIdIDRef_, ob);
                    }
                    else if (reportIdNode.Attributes["href"] != null)
                    {
                        reportIdIDRef_ = reportIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        reportId_ = new ReportId(reportIdNode);
                    }
                }
                else
                {
                    reportId_ = new ReportId(reportIdNode);
                }
            }


            XmlNode sectionNumberNode = xmlNode.SelectSingleNode("sectionNumber");

            if (sectionNumberNode != null)
            {
                if (sectionNumberNode.Attributes["href"] != null || sectionNumberNode.Attributes["id"] != null)
                {
                    if (sectionNumberNode.Attributes["id"] != null)
                    {
                        sectionNumberIDRef_ = sectionNumberNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sectionNumberNode);
                        IDManager.SetID(sectionNumberIDRef_, ob);
                    }
                    else if (sectionNumberNode.Attributes["href"] != null)
                    {
                        sectionNumberIDRef_ = sectionNumberNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sectionNumber_ = new XsdTypePositiveInteger(sectionNumberNode);
                    }
                }
                else
                {
                    sectionNumber_ = new XsdTypePositiveInteger(sectionNumberNode);
                }
            }
        }
        public SequencedDisruptionFallback(XmlNode xmlNode)
        {
            XmlNode fallbackNode = xmlNode.SelectSingleNode("fallback");

            if (fallbackNode != null)
            {
                if (fallbackNode.Attributes["href"] != null || fallbackNode.Attributes["id"] != null)
                {
                    if (fallbackNode.Attributes["id"] != null)
                    {
                        fallbackIDRef_ = fallbackNode.Attributes["id"].Value;
                        DisruptionFallback ob = new DisruptionFallback(fallbackNode);
                        IDManager.SetID(fallbackIDRef_, ob);
                    }
                    else if (fallbackNode.Attributes["href"] != null)
                    {
                        fallbackIDRef_ = fallbackNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fallback_ = new DisruptionFallback(fallbackNode);
                    }
                }
                else
                {
                    fallback_ = new DisruptionFallback(fallbackNode);
                }
            }


            XmlNode sequenceNode = xmlNode.SelectSingleNode("sequence");

            if (sequenceNode != null)
            {
                if (sequenceNode.Attributes["href"] != null || sequenceNode.Attributes["id"] != null)
                {
                    if (sequenceNode.Attributes["id"] != null)
                    {
                        sequenceIDRef_ = sequenceNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sequenceNode);
                        IDManager.SetID(sequenceIDRef_, ob);
                    }
                    else if (sequenceNode.Attributes["href"] != null)
                    {
                        sequenceIDRef_ = sequenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sequence_ = new XsdTypePositiveInteger(sequenceNode);
                    }
                }
                else
                {
                    sequence_ = new XsdTypePositiveInteger(sequenceNode);
                }
            }
        }
Beispiel #31
0
        public Frequency(XmlNode xmlNode)
        {
            XmlNode periodMultiplierNode = xmlNode.SelectSingleNode("periodMultiplier");

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


            XmlNode periodNode = xmlNode.SelectSingleNode("period");

            if (periodNode != null)
            {
                if (periodNode.Attributes["href"] != null || periodNode.Attributes["id"] != null)
                {
                    if (periodNode.Attributes["id"] != null)
                    {
                        periodIDRef_ = periodNode.Attributes["id"].Value;
                        PeriodExtendedEnum ob = new PeriodExtendedEnum(periodNode);
                        IDManager.SetID(periodIDRef_, ob);
                    }
                    else if (periodNode.Attributes["href"] != null)
                    {
                        periodIDRef_ = periodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        period_ = new PeriodExtendedEnum(periodNode);
                    }
                }
                else
                {
                    period_ = new PeriodExtendedEnum(periodNode);
                }
            }
        }
Beispiel #32
0
        public DenominatorTerm(XmlNode xmlNode)
        {
            XmlNode weightedPartialNode = xmlNode.SelectSingleNode("weightedPartial");

            if (weightedPartialNode != null)
            {
                if (weightedPartialNode.Attributes["href"] != null || weightedPartialNode.Attributes["id"] != null)
                {
                    if (weightedPartialNode.Attributes["id"] != null)
                    {
                        weightedPartialIDRef_ = weightedPartialNode.Attributes["id"].Value;
                        WeightedPartialDerivative ob = new WeightedPartialDerivative(weightedPartialNode);
                        IDManager.SetID(weightedPartialIDRef_, ob);
                    }
                    else if (weightedPartialNode.Attributes["href"] != null)
                    {
                        weightedPartialIDRef_ = weightedPartialNode.Attributes["href"].Value;
                    }
                    else
                    {
                        weightedPartial_ = new WeightedPartialDerivative(weightedPartialNode);
                    }
                }
                else
                {
                    weightedPartial_ = new WeightedPartialDerivative(weightedPartialNode);
                }
            }


            XmlNode powerNode = xmlNode.SelectSingleNode("power");

            if (powerNode != null)
            {
                if (powerNode.Attributes["href"] != null || powerNode.Attributes["id"] != null)
                {
                    if (powerNode.Attributes["id"] != null)
                    {
                        powerIDRef_ = powerNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(powerNode);
                        IDManager.SetID(powerIDRef_, ob);
                    }
                    else if (powerNode.Attributes["href"] != null)
                    {
                        powerIDRef_ = powerNode.Attributes["href"].Value;
                    }
                    else
                    {
                        power_ = new XsdTypePositiveInteger(powerNode);
                    }
                }
                else
                {
                    power_ = new XsdTypePositiveInteger(powerNode);
                }
            }
        }
 public CommodityFx(XmlNode xmlNode)
 {
     XmlNode primaryRateSourceNode = xmlNode.SelectSingleNode("primaryRateSource");
     
     if (primaryRateSourceNode != null)
     {
         if (primaryRateSourceNode.Attributes["href"] != null || primaryRateSourceNode.Attributes["id"] != null) 
         {
             if (primaryRateSourceNode.Attributes["id"] != null) 
             {
                 primaryRateSourceIDRef_ = primaryRateSourceNode.Attributes["id"].Value;
                 InformationSource ob = new InformationSource(primaryRateSourceNode);
                 IDManager.SetID(primaryRateSourceIDRef_, ob);
             }
             else if (primaryRateSourceNode.Attributes["href"] != null)
             {
                 primaryRateSourceIDRef_ = primaryRateSourceNode.Attributes["href"].Value;
             }
             else
             {
                 primaryRateSource_ = new InformationSource(primaryRateSourceNode);
             }
         }
         else
         {
             primaryRateSource_ = new InformationSource(primaryRateSourceNode);
         }
     }
     
 
     XmlNode secondaryRateSourceNode = xmlNode.SelectSingleNode("secondaryRateSource");
     
     if (secondaryRateSourceNode != null)
     {
         if (secondaryRateSourceNode.Attributes["href"] != null || secondaryRateSourceNode.Attributes["id"] != null) 
         {
             if (secondaryRateSourceNode.Attributes["id"] != null) 
             {
                 secondaryRateSourceIDRef_ = secondaryRateSourceNode.Attributes["id"].Value;
                 InformationSource ob = new InformationSource(secondaryRateSourceNode);
                 IDManager.SetID(secondaryRateSourceIDRef_, ob);
             }
             else if (secondaryRateSourceNode.Attributes["href"] != null)
             {
                 secondaryRateSourceIDRef_ = secondaryRateSourceNode.Attributes["href"].Value;
             }
             else
             {
                 secondaryRateSource_ = new InformationSource(secondaryRateSourceNode);
             }
         }
         else
         {
             secondaryRateSource_ = new InformationSource(secondaryRateSourceNode);
         }
     }
     
 
     XmlNode fxTypeNode = xmlNode.SelectSingleNode("fxType");
     
     if (fxTypeNode != null)
     {
         if (fxTypeNode.Attributes["href"] != null || fxTypeNode.Attributes["id"] != null) 
         {
             if (fxTypeNode.Attributes["id"] != null) 
             {
                 fxTypeIDRef_ = fxTypeNode.Attributes["id"].Value;
                 CommodityFxType ob = new CommodityFxType(fxTypeNode);
                 IDManager.SetID(fxTypeIDRef_, ob);
             }
             else if (fxTypeNode.Attributes["href"] != null)
             {
                 fxTypeIDRef_ = fxTypeNode.Attributes["href"].Value;
             }
             else
             {
                 fxType_ = new CommodityFxType(fxTypeNode);
             }
         }
         else
         {
             fxType_ = new CommodityFxType(fxTypeNode);
         }
     }
     
 
     XmlNode averagingMethodNode = xmlNode.SelectSingleNode("averagingMethod");
     
     if (averagingMethodNode != null)
     {
         if (averagingMethodNode.Attributes["href"] != null || averagingMethodNode.Attributes["id"] != null) 
         {
             if (averagingMethodNode.Attributes["id"] != null) 
             {
                 averagingMethodIDRef_ = averagingMethodNode.Attributes["id"].Value;
                 AveragingMethodEnum ob = new AveragingMethodEnum(averagingMethodNode);
                 IDManager.SetID(averagingMethodIDRef_, ob);
             }
             else if (averagingMethodNode.Attributes["href"] != null)
             {
                 averagingMethodIDRef_ = averagingMethodNode.Attributes["href"].Value;
             }
             else
             {
                 averagingMethod_ = new AveragingMethodEnum(averagingMethodNode);
             }
         }
         else
         {
             averagingMethod_ = new AveragingMethodEnum(averagingMethodNode);
         }
     }
     
 
     XmlNode fixingTimeNode = xmlNode.SelectSingleNode("fixingTime");
     
     if (fixingTimeNode != null)
     {
         if (fixingTimeNode.Attributes["href"] != null || fixingTimeNode.Attributes["id"] != null) 
         {
             if (fixingTimeNode.Attributes["id"] != null) 
             {
                 fixingTimeIDRef_ = fixingTimeNode.Attributes["id"].Value;
                 BusinessCenterTime ob = new BusinessCenterTime(fixingTimeNode);
                 IDManager.SetID(fixingTimeIDRef_, ob);
             }
             else if (fixingTimeNode.Attributes["href"] != null)
             {
                 fixingTimeIDRef_ = fixingTimeNode.Attributes["href"].Value;
             }
             else
             {
                 fixingTime_ = new BusinessCenterTime(fixingTimeNode);
             }
         }
         else
         {
             fixingTime_ = new BusinessCenterTime(fixingTimeNode);
         }
     }
     
 
     XmlNodeList fxObservationDatesNodeList = xmlNode.SelectNodes("fxObservationDates");
     
     if (fxObservationDatesNodeList != null)
     {
         this.fxObservationDates_ = new List<AdjustableDates>();
         foreach (XmlNode item in fxObservationDatesNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     fxObservationDatesIDRef_ = item.Attributes["id"].Value;
                     fxObservationDates_.Add(new AdjustableDates(item));
                     IDManager.SetID(fxObservationDatesIDRef_, fxObservationDates_[fxObservationDates_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     fxObservationDatesIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 fxObservationDates_.Add(new AdjustableDates(item));
                 }
             }
             else
             {
                 fxObservationDates_.Add(new AdjustableDates(item));
             }
         }
     }
     
 
     XmlNode dayTypeNode = xmlNode.SelectSingleNode("dayType");
     
     if (dayTypeNode != null)
     {
         if (dayTypeNode.Attributes["href"] != null || dayTypeNode.Attributes["id"] != null) 
         {
             if (dayTypeNode.Attributes["id"] != null) 
             {
                 dayTypeIDRef_ = dayTypeNode.Attributes["id"].Value;
                 CommodityDayTypeEnum ob = new CommodityDayTypeEnum(dayTypeNode);
                 IDManager.SetID(dayTypeIDRef_, ob);
             }
             else if (dayTypeNode.Attributes["href"] != null)
             {
                 dayTypeIDRef_ = dayTypeNode.Attributes["href"].Value;
             }
             else
             {
                 dayType_ = new CommodityDayTypeEnum(dayTypeNode);
             }
         }
         else
         {
             dayType_ = new CommodityDayTypeEnum(dayTypeNode);
         }
     }
     
 
     XmlNode dayDistributionNode = xmlNode.SelectSingleNode("dayDistribution");
     
     if (dayDistributionNode != null)
     {
         if (dayDistributionNode.Attributes["href"] != null || dayDistributionNode.Attributes["id"] != null) 
         {
             if (dayDistributionNode.Attributes["id"] != null) 
             {
                 dayDistributionIDRef_ = dayDistributionNode.Attributes["id"].Value;
                 CommodityFrequencyType ob = new CommodityFrequencyType(dayDistributionNode);
                 IDManager.SetID(dayDistributionIDRef_, ob);
             }
             else if (dayDistributionNode.Attributes["href"] != null)
             {
                 dayDistributionIDRef_ = dayDistributionNode.Attributes["href"].Value;
             }
             else
             {
                 dayDistribution_ = new CommodityFrequencyType(dayDistributionNode);
             }
         }
         else
         {
             dayDistribution_ = new CommodityFrequencyType(dayDistributionNode);
         }
     }
     
 
     XmlNode dayCountNode = xmlNode.SelectSingleNode("dayCount");
     
     if (dayCountNode != null)
     {
         if (dayCountNode.Attributes["href"] != null || dayCountNode.Attributes["id"] != null) 
         {
             if (dayCountNode.Attributes["id"] != null) 
             {
                 dayCountIDRef_ = dayCountNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(dayCountNode);
                 IDManager.SetID(dayCountIDRef_, ob);
             }
             else if (dayCountNode.Attributes["href"] != null)
             {
                 dayCountIDRef_ = dayCountNode.Attributes["href"].Value;
             }
             else
             {
                 dayCount_ = new XsdTypePositiveInteger(dayCountNode);
             }
         }
         else
         {
             dayCount_ = new XsdTypePositiveInteger(dayCountNode);
         }
     }
     
 
     XmlNodeList dayOfWeekNodeList = xmlNode.SelectNodes("dayOfWeek");
     
     if (dayOfWeekNodeList != null)
     {
         this.dayOfWeek_ = new List<DayOfWeekEnum>();
         foreach (XmlNode item in dayOfWeekNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     dayOfWeekIDRef_ = item.Attributes["id"].Value;
                     dayOfWeek_.Add(new DayOfWeekEnum(item));
                     IDManager.SetID(dayOfWeekIDRef_, dayOfWeek_[dayOfWeek_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     dayOfWeekIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 dayOfWeek_.Add(new DayOfWeekEnum(item));
                 }
             }
             else
             {
                 dayOfWeek_.Add(new DayOfWeekEnum(item));
             }
         }
     }
     
 
     XmlNode dayNumberNode = xmlNode.SelectSingleNode("dayNumber");
     
     if (dayNumberNode != null)
     {
         if (dayNumberNode.Attributes["href"] != null || dayNumberNode.Attributes["id"] != null) 
         {
             if (dayNumberNode.Attributes["id"] != null) 
             {
                 dayNumberIDRef_ = dayNumberNode.Attributes["id"].Value;
                 XsdTypeInteger ob = new XsdTypeInteger(dayNumberNode);
                 IDManager.SetID(dayNumberIDRef_, ob);
             }
             else if (dayNumberNode.Attributes["href"] != null)
             {
                 dayNumberIDRef_ = dayNumberNode.Attributes["href"].Value;
             }
             else
             {
                 dayNumber_ = new XsdTypeInteger(dayNumberNode);
             }
         }
         else
         {
             dayNumber_ = new XsdTypeInteger(dayNumberNode);
         }
     }
     
 
     XmlNode lagNode = xmlNode.SelectSingleNode("lag");
     
     if (lagNode != null)
     {
         if (lagNode.Attributes["href"] != null || lagNode.Attributes["id"] != null) 
         {
             if (lagNode.Attributes["id"] != null) 
             {
                 lagIDRef_ = lagNode.Attributes["id"].Value;
                 Lag ob = new Lag(lagNode);
                 IDManager.SetID(lagIDRef_, ob);
             }
             else if (lagNode.Attributes["href"] != null)
             {
                 lagIDRef_ = lagNode.Attributes["href"].Value;
             }
             else
             {
                 lag_ = new Lag(lagNode);
             }
         }
         else
         {
             lag_ = new Lag(lagNode);
         }
     }
     
 
     XmlNode lagReferenceNode = xmlNode.SelectSingleNode("lagReference");
     
     if (lagReferenceNode != null)
     {
         if (lagReferenceNode.Attributes["href"] != null || lagReferenceNode.Attributes["id"] != null) 
         {
             if (lagReferenceNode.Attributes["id"] != null) 
             {
                 lagReferenceIDRef_ = lagReferenceNode.Attributes["id"].Value;
                 LagReference ob = new LagReference(lagReferenceNode);
                 IDManager.SetID(lagReferenceIDRef_, ob);
             }
             else if (lagReferenceNode.Attributes["href"] != null)
             {
                 lagReferenceIDRef_ = lagReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 lagReference_ = new LagReference(lagReferenceNode);
             }
         }
         else
         {
             lagReference_ = new LagReference(lagReferenceNode);
         }
     }
     
 
     XmlNode calculationPeriodsReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsReference");
     
     if (calculationPeriodsReferenceNode != null)
     {
         if (calculationPeriodsReferenceNode.Attributes["href"] != null || calculationPeriodsReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsReferenceIDRef_ = calculationPeriodsReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsReference ob = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
                 IDManager.SetID(calculationPeriodsReferenceIDRef_, ob);
             }
             else if (calculationPeriodsReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsReferenceIDRef_ = calculationPeriodsReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsReference_ = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
             }
         }
         else
         {
             calculationPeriodsReference_ = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
         }
     }
     
 
     XmlNode calculationPeriodsScheduleReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsScheduleReference");
     
     if (calculationPeriodsScheduleReferenceNode != null)
     {
         if (calculationPeriodsScheduleReferenceNode.Attributes["href"] != null || calculationPeriodsScheduleReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsScheduleReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsScheduleReferenceIDRef_ = calculationPeriodsScheduleReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsScheduleReference ob = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
                 IDManager.SetID(calculationPeriodsScheduleReferenceIDRef_, ob);
             }
             else if (calculationPeriodsScheduleReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsScheduleReferenceIDRef_ = calculationPeriodsScheduleReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsScheduleReference_ = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
             }
         }
         else
         {
             calculationPeriodsScheduleReference_ = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
         }
     }
     
 
     XmlNode calculationPeriodsDatesReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsDatesReference");
     
     if (calculationPeriodsDatesReferenceNode != null)
     {
         if (calculationPeriodsDatesReferenceNode.Attributes["href"] != null || calculationPeriodsDatesReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsDatesReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsDatesReferenceIDRef_ = calculationPeriodsDatesReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsDatesReference ob = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
                 IDManager.SetID(calculationPeriodsDatesReferenceIDRef_, ob);
             }
             else if (calculationPeriodsDatesReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsDatesReferenceIDRef_ = calculationPeriodsDatesReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsDatesReference_ = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
             }
         }
         else
         {
             calculationPeriodsDatesReference_ = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
         }
     }
     
 
 }
 public IndexReferenceInformation(XmlNode xmlNode)
 {
     XmlNode indexNameNode = xmlNode.SelectSingleNode("indexName");
     
     if (indexNameNode != null)
     {
         if (indexNameNode.Attributes["href"] != null || indexNameNode.Attributes["id"] != null) 
         {
             if (indexNameNode.Attributes["id"] != null) 
             {
                 indexNameIDRef_ = indexNameNode.Attributes["id"].Value;
                 IndexName ob = new IndexName(indexNameNode);
                 IDManager.SetID(indexNameIDRef_, ob);
             }
             else if (indexNameNode.Attributes["href"] != null)
             {
                 indexNameIDRef_ = indexNameNode.Attributes["href"].Value;
             }
             else
             {
                 indexName_ = new IndexName(indexNameNode);
             }
         }
         else
         {
             indexName_ = new IndexName(indexNameNode);
         }
     }
     
 
     XmlNodeList indexIdNodeList = xmlNode.SelectNodes("indexId");
     
     if (indexIdNodeList != null)
     {
         this.indexId_ = new List<IndexId>();
         foreach (XmlNode item in indexIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     indexIdIDRef_ = item.Attributes["id"].Value;
                     indexId_.Add(new IndexId(item));
                     IDManager.SetID(indexIdIDRef_, indexId_[indexId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     indexIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 indexId_.Add(new IndexId(item));
                 }
             }
             else
             {
                 indexId_.Add(new IndexId(item));
             }
         }
     }
     
 
     XmlNode indexSeriesNode = xmlNode.SelectSingleNode("indexSeries");
     
     if (indexSeriesNode != null)
     {
         if (indexSeriesNode.Attributes["href"] != null || indexSeriesNode.Attributes["id"] != null) 
         {
             if (indexSeriesNode.Attributes["id"] != null) 
             {
                 indexSeriesIDRef_ = indexSeriesNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(indexSeriesNode);
                 IDManager.SetID(indexSeriesIDRef_, ob);
             }
             else if (indexSeriesNode.Attributes["href"] != null)
             {
                 indexSeriesIDRef_ = indexSeriesNode.Attributes["href"].Value;
             }
             else
             {
                 indexSeries_ = new XsdTypePositiveInteger(indexSeriesNode);
             }
         }
         else
         {
             indexSeries_ = new XsdTypePositiveInteger(indexSeriesNode);
         }
     }
     
 
     XmlNode indexAnnexVersionNode = xmlNode.SelectSingleNode("indexAnnexVersion");
     
     if (indexAnnexVersionNode != null)
     {
         if (indexAnnexVersionNode.Attributes["href"] != null || indexAnnexVersionNode.Attributes["id"] != null) 
         {
             if (indexAnnexVersionNode.Attributes["id"] != null) 
             {
                 indexAnnexVersionIDRef_ = indexAnnexVersionNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(indexAnnexVersionNode);
                 IDManager.SetID(indexAnnexVersionIDRef_, ob);
             }
             else if (indexAnnexVersionNode.Attributes["href"] != null)
             {
                 indexAnnexVersionIDRef_ = indexAnnexVersionNode.Attributes["href"].Value;
             }
             else
             {
                 indexAnnexVersion_ = new XsdTypePositiveInteger(indexAnnexVersionNode);
             }
         }
         else
         {
             indexAnnexVersion_ = new XsdTypePositiveInteger(indexAnnexVersionNode);
         }
     }
     
 
     XmlNode indexAnnexDateNode = xmlNode.SelectSingleNode("indexAnnexDate");
     
     if (indexAnnexDateNode != null)
     {
         if (indexAnnexDateNode.Attributes["href"] != null || indexAnnexDateNode.Attributes["id"] != null) 
         {
             if (indexAnnexDateNode.Attributes["id"] != null) 
             {
                 indexAnnexDateIDRef_ = indexAnnexDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(indexAnnexDateNode);
                 IDManager.SetID(indexAnnexDateIDRef_, ob);
             }
             else if (indexAnnexDateNode.Attributes["href"] != null)
             {
                 indexAnnexDateIDRef_ = indexAnnexDateNode.Attributes["href"].Value;
             }
             else
             {
                 indexAnnexDate_ = new XsdTypeDate(indexAnnexDateNode);
             }
         }
         else
         {
             indexAnnexDate_ = new XsdTypeDate(indexAnnexDateNode);
         }
     }
     
 
     XmlNode indexAnnexSourceNode = xmlNode.SelectSingleNode("indexAnnexSource");
     
     if (indexAnnexSourceNode != null)
     {
         if (indexAnnexSourceNode.Attributes["href"] != null || indexAnnexSourceNode.Attributes["id"] != null) 
         {
             if (indexAnnexSourceNode.Attributes["id"] != null) 
             {
                 indexAnnexSourceIDRef_ = indexAnnexSourceNode.Attributes["id"].Value;
                 IndexAnnexSource ob = new IndexAnnexSource(indexAnnexSourceNode);
                 IDManager.SetID(indexAnnexSourceIDRef_, ob);
             }
             else if (indexAnnexSourceNode.Attributes["href"] != null)
             {
                 indexAnnexSourceIDRef_ = indexAnnexSourceNode.Attributes["href"].Value;
             }
             else
             {
                 indexAnnexSource_ = new IndexAnnexSource(indexAnnexSourceNode);
             }
         }
         else
         {
             indexAnnexSource_ = new IndexAnnexSource(indexAnnexSourceNode);
         }
     }
     
 
     XmlNodeList excludedReferenceEntityNodeList = xmlNode.SelectNodes("excludedReferenceEntity");
     
     if (excludedReferenceEntityNodeList != null)
     {
         this.excludedReferenceEntity_ = new List<LegalEntity>();
         foreach (XmlNode item in excludedReferenceEntityNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     excludedReferenceEntityIDRef_ = item.Attributes["id"].Value;
                     excludedReferenceEntity_.Add(new LegalEntity(item));
                     IDManager.SetID(excludedReferenceEntityIDRef_, excludedReferenceEntity_[excludedReferenceEntity_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     excludedReferenceEntityIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 excludedReferenceEntity_.Add(new LegalEntity(item));
                 }
             }
             else
             {
                 excludedReferenceEntity_.Add(new LegalEntity(item));
             }
         }
     }
     
 
     XmlNode trancheNode = xmlNode.SelectSingleNode("tranche");
     
     if (trancheNode != null)
     {
         if (trancheNode.Attributes["href"] != null || trancheNode.Attributes["id"] != null) 
         {
             if (trancheNode.Attributes["id"] != null) 
             {
                 trancheIDRef_ = trancheNode.Attributes["id"].Value;
                 Tranche ob = new Tranche(trancheNode);
                 IDManager.SetID(trancheIDRef_, ob);
             }
             else if (trancheNode.Attributes["href"] != null)
             {
                 trancheIDRef_ = trancheNode.Attributes["href"].Value;
             }
             else
             {
                 tranche_ = new Tranche(trancheNode);
             }
         }
         else
         {
             tranche_ = new Tranche(trancheNode);
         }
     }
     
 
     XmlNode settledEntityMatrixNode = xmlNode.SelectSingleNode("settledEntityMatrix");
     
     if (settledEntityMatrixNode != null)
     {
         if (settledEntityMatrixNode.Attributes["href"] != null || settledEntityMatrixNode.Attributes["id"] != null) 
         {
             if (settledEntityMatrixNode.Attributes["id"] != null) 
             {
                 settledEntityMatrixIDRef_ = settledEntityMatrixNode.Attributes["id"].Value;
                 SettledEntityMatrix ob = new SettledEntityMatrix(settledEntityMatrixNode);
                 IDManager.SetID(settledEntityMatrixIDRef_, ob);
             }
             else if (settledEntityMatrixNode.Attributes["href"] != null)
             {
                 settledEntityMatrixIDRef_ = settledEntityMatrixNode.Attributes["href"].Value;
             }
             else
             {
                 settledEntityMatrix_ = new SettledEntityMatrix(settledEntityMatrixNode);
             }
         }
         else
         {
             settledEntityMatrix_ = new SettledEntityMatrix(settledEntityMatrixNode);
         }
     }
     
 
 }
 public IntermediaryInformation(XmlNode xmlNode)
 {
     XmlNode routingIdsNode = xmlNode.SelectSingleNode("routingIds");
     
     if (routingIdsNode != null)
     {
         if (routingIdsNode.Attributes["href"] != null || routingIdsNode.Attributes["id"] != null) 
         {
             if (routingIdsNode.Attributes["id"] != null) 
             {
                 routingIdsIDRef_ = routingIdsNode.Attributes["id"].Value;
                 RoutingIds ob = new RoutingIds(routingIdsNode);
                 IDManager.SetID(routingIdsIDRef_, ob);
             }
             else if (routingIdsNode.Attributes["href"] != null)
             {
                 routingIdsIDRef_ = routingIdsNode.Attributes["href"].Value;
             }
             else
             {
                 routingIds_ = new RoutingIds(routingIdsNode);
             }
         }
         else
         {
             routingIds_ = new RoutingIds(routingIdsNode);
         }
     }
     
 
     XmlNode routingExplicitDetailsNode = xmlNode.SelectSingleNode("routingExplicitDetails");
     
     if (routingExplicitDetailsNode != null)
     {
         if (routingExplicitDetailsNode.Attributes["href"] != null || routingExplicitDetailsNode.Attributes["id"] != null) 
         {
             if (routingExplicitDetailsNode.Attributes["id"] != null) 
             {
                 routingExplicitDetailsIDRef_ = routingExplicitDetailsNode.Attributes["id"].Value;
                 RoutingExplicitDetails ob = new RoutingExplicitDetails(routingExplicitDetailsNode);
                 IDManager.SetID(routingExplicitDetailsIDRef_, ob);
             }
             else if (routingExplicitDetailsNode.Attributes["href"] != null)
             {
                 routingExplicitDetailsIDRef_ = routingExplicitDetailsNode.Attributes["href"].Value;
             }
             else
             {
                 routingExplicitDetails_ = new RoutingExplicitDetails(routingExplicitDetailsNode);
             }
         }
         else
         {
             routingExplicitDetails_ = new RoutingExplicitDetails(routingExplicitDetailsNode);
         }
     }
     
 
     XmlNode routingIdsAndExplicitDetailsNode = xmlNode.SelectSingleNode("routingIdsAndExplicitDetails");
     
     if (routingIdsAndExplicitDetailsNode != null)
     {
         if (routingIdsAndExplicitDetailsNode.Attributes["href"] != null || routingIdsAndExplicitDetailsNode.Attributes["id"] != null) 
         {
             if (routingIdsAndExplicitDetailsNode.Attributes["id"] != null) 
             {
                 routingIdsAndExplicitDetailsIDRef_ = routingIdsAndExplicitDetailsNode.Attributes["id"].Value;
                 RoutingIdsAndExplicitDetails ob = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
                 IDManager.SetID(routingIdsAndExplicitDetailsIDRef_, ob);
             }
             else if (routingIdsAndExplicitDetailsNode.Attributes["href"] != null)
             {
                 routingIdsAndExplicitDetailsIDRef_ = routingIdsAndExplicitDetailsNode.Attributes["href"].Value;
             }
             else
             {
                 routingIdsAndExplicitDetails_ = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
             }
         }
         else
         {
             routingIdsAndExplicitDetails_ = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
         }
     }
     
 
     XmlNode intermediarySequenceNumberNode = xmlNode.SelectSingleNode("intermediarySequenceNumber");
     
     if (intermediarySequenceNumberNode != null)
     {
         if (intermediarySequenceNumberNode.Attributes["href"] != null || intermediarySequenceNumberNode.Attributes["id"] != null) 
         {
             if (intermediarySequenceNumberNode.Attributes["id"] != null) 
             {
                 intermediarySequenceNumberIDRef_ = intermediarySequenceNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(intermediarySequenceNumberNode);
                 IDManager.SetID(intermediarySequenceNumberIDRef_, ob);
             }
             else if (intermediarySequenceNumberNode.Attributes["href"] != null)
             {
                 intermediarySequenceNumberIDRef_ = intermediarySequenceNumberNode.Attributes["href"].Value;
             }
             else
             {
                 intermediarySequenceNumber_ = new XsdTypePositiveInteger(intermediarySequenceNumberNode);
             }
         }
         else
         {
             intermediarySequenceNumber_ = new XsdTypePositiveInteger(intermediarySequenceNumberNode);
         }
     }
     
 
     XmlNode intermediaryPartyReferenceNode = xmlNode.SelectSingleNode("intermediaryPartyReference");
     
     if (intermediaryPartyReferenceNode != null)
     {
         if (intermediaryPartyReferenceNode.Attributes["href"] != null || intermediaryPartyReferenceNode.Attributes["id"] != null) 
         {
             if (intermediaryPartyReferenceNode.Attributes["id"] != null) 
             {
                 intermediaryPartyReferenceIDRef_ = intermediaryPartyReferenceNode.Attributes["id"].Value;
                 PartyReference ob = new PartyReference(intermediaryPartyReferenceNode);
                 IDManager.SetID(intermediaryPartyReferenceIDRef_, ob);
             }
             else if (intermediaryPartyReferenceNode.Attributes["href"] != null)
             {
                 intermediaryPartyReferenceIDRef_ = intermediaryPartyReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 intermediaryPartyReference_ = new PartyReference(intermediaryPartyReferenceNode);
             }
         }
         else
         {
             intermediaryPartyReference_ = new PartyReference(intermediaryPartyReferenceNode);
         }
     }
     
 
 }
 public RateObservation(XmlNode xmlNode)
 {
     XmlNode resetDateNode = xmlNode.SelectSingleNode("resetDate");
     
     if (resetDateNode != null)
     {
         if (resetDateNode.Attributes["href"] != null || resetDateNode.Attributes["id"] != null) 
         {
             if (resetDateNode.Attributes["id"] != null) 
             {
                 resetDateIDRef_ = resetDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(resetDateNode);
                 IDManager.SetID(resetDateIDRef_, ob);
             }
             else if (resetDateNode.Attributes["href"] != null)
             {
                 resetDateIDRef_ = resetDateNode.Attributes["href"].Value;
             }
             else
             {
                 resetDate_ = new XsdTypeDate(resetDateNode);
             }
         }
         else
         {
             resetDate_ = new XsdTypeDate(resetDateNode);
         }
     }
     
 
     XmlNode adjustedFixingDateNode = xmlNode.SelectSingleNode("adjustedFixingDate");
     
     if (adjustedFixingDateNode != null)
     {
         if (adjustedFixingDateNode.Attributes["href"] != null || adjustedFixingDateNode.Attributes["id"] != null) 
         {
             if (adjustedFixingDateNode.Attributes["id"] != null) 
             {
                 adjustedFixingDateIDRef_ = adjustedFixingDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(adjustedFixingDateNode);
                 IDManager.SetID(adjustedFixingDateIDRef_, ob);
             }
             else if (adjustedFixingDateNode.Attributes["href"] != null)
             {
                 adjustedFixingDateIDRef_ = adjustedFixingDateNode.Attributes["href"].Value;
             }
             else
             {
                 adjustedFixingDate_ = new XsdTypeDate(adjustedFixingDateNode);
             }
         }
         else
         {
             adjustedFixingDate_ = new XsdTypeDate(adjustedFixingDateNode);
         }
     }
     
 
     XmlNode observedRateNode = xmlNode.SelectSingleNode("observedRate");
     
     if (observedRateNode != null)
     {
         if (observedRateNode.Attributes["href"] != null || observedRateNode.Attributes["id"] != null) 
         {
             if (observedRateNode.Attributes["id"] != null) 
             {
                 observedRateIDRef_ = observedRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(observedRateNode);
                 IDManager.SetID(observedRateIDRef_, ob);
             }
             else if (observedRateNode.Attributes["href"] != null)
             {
                 observedRateIDRef_ = observedRateNode.Attributes["href"].Value;
             }
             else
             {
                 observedRate_ = new XsdTypeDecimal(observedRateNode);
             }
         }
         else
         {
             observedRate_ = new XsdTypeDecimal(observedRateNode);
         }
     }
     
 
     XmlNode treatedRateNode = xmlNode.SelectSingleNode("treatedRate");
     
     if (treatedRateNode != null)
     {
         if (treatedRateNode.Attributes["href"] != null || treatedRateNode.Attributes["id"] != null) 
         {
             if (treatedRateNode.Attributes["id"] != null) 
             {
                 treatedRateIDRef_ = treatedRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(treatedRateNode);
                 IDManager.SetID(treatedRateIDRef_, ob);
             }
             else if (treatedRateNode.Attributes["href"] != null)
             {
                 treatedRateIDRef_ = treatedRateNode.Attributes["href"].Value;
             }
             else
             {
                 treatedRate_ = new XsdTypeDecimal(treatedRateNode);
             }
         }
         else
         {
             treatedRate_ = new XsdTypeDecimal(treatedRateNode);
         }
     }
     
 
     XmlNode observationWeightNode = xmlNode.SelectSingleNode("observationWeight");
     
     if (observationWeightNode != null)
     {
         if (observationWeightNode.Attributes["href"] != null || observationWeightNode.Attributes["id"] != null) 
         {
             if (observationWeightNode.Attributes["id"] != null) 
             {
                 observationWeightIDRef_ = observationWeightNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(observationWeightNode);
                 IDManager.SetID(observationWeightIDRef_, ob);
             }
             else if (observationWeightNode.Attributes["href"] != null)
             {
                 observationWeightIDRef_ = observationWeightNode.Attributes["href"].Value;
             }
             else
             {
                 observationWeight_ = new XsdTypePositiveInteger(observationWeightNode);
             }
         }
         else
         {
             observationWeight_ = new XsdTypePositiveInteger(observationWeightNode);
         }
     }
     
 
     XmlNode rateReferenceNode = xmlNode.SelectSingleNode("rateReference");
     
     if (rateReferenceNode != null)
     {
         if (rateReferenceNode.Attributes["href"] != null || rateReferenceNode.Attributes["id"] != null) 
         {
             if (rateReferenceNode.Attributes["id"] != null) 
             {
                 rateReferenceIDRef_ = rateReferenceNode.Attributes["id"].Value;
                 RateReference ob = new RateReference(rateReferenceNode);
                 IDManager.SetID(rateReferenceIDRef_, ob);
             }
             else if (rateReferenceNode.Attributes["href"] != null)
             {
                 rateReferenceIDRef_ = rateReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 rateReference_ = new RateReference(rateReferenceNode);
             }
         }
         else
         {
             rateReference_ = new RateReference(rateReferenceNode);
         }
     }
     
 
     XmlNode forecastRateNode = xmlNode.SelectSingleNode("forecastRate");
     
     if (forecastRateNode != null)
     {
         if (forecastRateNode.Attributes["href"] != null || forecastRateNode.Attributes["id"] != null) 
         {
             if (forecastRateNode.Attributes["id"] != null) 
             {
                 forecastRateIDRef_ = forecastRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(forecastRateNode);
                 IDManager.SetID(forecastRateIDRef_, ob);
             }
             else if (forecastRateNode.Attributes["href"] != null)
             {
                 forecastRateIDRef_ = forecastRateNode.Attributes["href"].Value;
             }
             else
             {
                 forecastRate_ = new XsdTypeDecimal(forecastRateNode);
             }
         }
         else
         {
             forecastRate_ = new XsdTypeDecimal(forecastRateNode);
         }
     }
     
 
     XmlNode treatedForecastRateNode = xmlNode.SelectSingleNode("treatedForecastRate");
     
     if (treatedForecastRateNode != null)
     {
         if (treatedForecastRateNode.Attributes["href"] != null || treatedForecastRateNode.Attributes["id"] != null) 
         {
             if (treatedForecastRateNode.Attributes["id"] != null) 
             {
                 treatedForecastRateIDRef_ = treatedForecastRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(treatedForecastRateNode);
                 IDManager.SetID(treatedForecastRateIDRef_, ob);
             }
             else if (treatedForecastRateNode.Attributes["href"] != null)
             {
                 treatedForecastRateIDRef_ = treatedForecastRateNode.Attributes["href"].Value;
             }
             else
             {
                 treatedForecastRate_ = new XsdTypeDecimal(treatedForecastRateNode);
             }
         }
         else
         {
             treatedForecastRate_ = new XsdTypeDecimal(treatedForecastRateNode);
         }
     }
     
 
 }
 public ResponseMessage(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode headerNode = xmlNode.SelectSingleNode("header");
     
     if (headerNode != null)
     {
         if (headerNode.Attributes["href"] != null || headerNode.Attributes["id"] != null) 
         {
             if (headerNode.Attributes["id"] != null) 
             {
                 headerIDRef_ = headerNode.Attributes["id"].Value;
                 ResponseMessageHeader ob = new ResponseMessageHeader(headerNode);
                 IDManager.SetID(headerIDRef_, ob);
             }
             else if (headerNode.Attributes["href"] != null)
             {
                 headerIDRef_ = headerNode.Attributes["href"].Value;
             }
             else
             {
                 header_ = new ResponseMessageHeader(headerNode);
             }
         }
         else
         {
             header_ = new ResponseMessageHeader(headerNode);
         }
     }
     
 
     XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");
     
     if (validationNodeList != null)
     {
         this.validation_ = new List<Validation>();
         foreach (XmlNode item in validationNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     validationIDRef_ = item.Attributes["id"].Value;
                     validation_.Add(new Validation(item));
                     IDManager.SetID(validationIDRef_, validation_[validation_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     validationIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 validation_.Add(new Validation(item));
                 }
             }
             else
             {
                 validation_.Add(new Validation(item));
             }
         }
     }
     
 
     XmlNode parentCorrelationIdNode = xmlNode.SelectSingleNode("parentCorrelationId");
     
     if (parentCorrelationIdNode != null)
     {
         if (parentCorrelationIdNode.Attributes["href"] != null || parentCorrelationIdNode.Attributes["id"] != null) 
         {
             if (parentCorrelationIdNode.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(parentCorrelationIdNode);
                 IDManager.SetID(parentCorrelationIdIDRef_, ob);
             }
             else if (parentCorrelationIdNode.Attributes["href"] != null)
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["href"].Value;
             }
             else
             {
                 parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
             }
         }
         else
         {
             parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
         }
     }
     
 
     XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");
     
     if (correlationIdNode != null)
     {
         if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null) 
         {
             if (correlationIdNode.Attributes["id"] != null) 
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(correlationIdNode);
                 IDManager.SetID(correlationIdIDRef_, ob);
             }
             else if (correlationIdNode.Attributes["href"] != null)
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
             }
             else
             {
                 correlationId_ = new CorrelationId(correlationIdNode);
             }
         }
         else
         {
             correlationId_ = new CorrelationId(correlationIdNode);
         }
     }
     
 
     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 onBehalfOfNode = xmlNode.SelectSingleNode("onBehalfOf");
     
     if (onBehalfOfNode != null)
     {
         if (onBehalfOfNode.Attributes["href"] != null || onBehalfOfNode.Attributes["id"] != null) 
         {
             if (onBehalfOfNode.Attributes["id"] != null) 
             {
                 onBehalfOfIDRef_ = onBehalfOfNode.Attributes["id"].Value;
                 OnBehalfOf ob = new OnBehalfOf(onBehalfOfNode);
                 IDManager.SetID(onBehalfOfIDRef_, ob);
             }
             else if (onBehalfOfNode.Attributes["href"] != null)
             {
                 onBehalfOfIDRef_ = onBehalfOfNode.Attributes["href"].Value;
             }
             else
             {
                 onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
             }
         }
         else
         {
             onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
         }
     }
     
 
 }
 public Correlation(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode notionalAmountNode = xmlNode.SelectSingleNode("notionalAmount");
     
     if (notionalAmountNode != null)
     {
         if (notionalAmountNode.Attributes["href"] != null || notionalAmountNode.Attributes["id"] != null) 
         {
             if (notionalAmountNode.Attributes["id"] != null) 
             {
                 notionalAmountIDRef_ = notionalAmountNode.Attributes["id"].Value;
                 NonNegativeMoney ob = new NonNegativeMoney(notionalAmountNode);
                 IDManager.SetID(notionalAmountIDRef_, ob);
             }
             else if (notionalAmountNode.Attributes["href"] != null)
             {
                 notionalAmountIDRef_ = notionalAmountNode.Attributes["href"].Value;
             }
             else
             {
                 notionalAmount_ = new NonNegativeMoney(notionalAmountNode);
             }
         }
         else
         {
             notionalAmount_ = new NonNegativeMoney(notionalAmountNode);
         }
     }
     
 
     XmlNode correlationStrikePriceNode = xmlNode.SelectSingleNode("correlationStrikePrice");
     
     if (correlationStrikePriceNode != null)
     {
         if (correlationStrikePriceNode.Attributes["href"] != null || correlationStrikePriceNode.Attributes["id"] != null) 
         {
             if (correlationStrikePriceNode.Attributes["id"] != null) 
             {
                 correlationStrikePriceIDRef_ = correlationStrikePriceNode.Attributes["id"].Value;
                 CorrelationValue ob = new CorrelationValue(correlationStrikePriceNode);
                 IDManager.SetID(correlationStrikePriceIDRef_, ob);
             }
             else if (correlationStrikePriceNode.Attributes["href"] != null)
             {
                 correlationStrikePriceIDRef_ = correlationStrikePriceNode.Attributes["href"].Value;
             }
             else
             {
                 correlationStrikePrice_ = new CorrelationValue(correlationStrikePriceNode);
             }
         }
         else
         {
             correlationStrikePrice_ = new CorrelationValue(correlationStrikePriceNode);
         }
     }
     
 
     XmlNode boundedCorrelationNode = xmlNode.SelectSingleNode("boundedCorrelation");
     
     if (boundedCorrelationNode != null)
     {
         if (boundedCorrelationNode.Attributes["href"] != null || boundedCorrelationNode.Attributes["id"] != null) 
         {
             if (boundedCorrelationNode.Attributes["id"] != null) 
             {
                 boundedCorrelationIDRef_ = boundedCorrelationNode.Attributes["id"].Value;
                 BoundedCorrelation ob = new BoundedCorrelation(boundedCorrelationNode);
                 IDManager.SetID(boundedCorrelationIDRef_, ob);
             }
             else if (boundedCorrelationNode.Attributes["href"] != null)
             {
                 boundedCorrelationIDRef_ = boundedCorrelationNode.Attributes["href"].Value;
             }
             else
             {
                 boundedCorrelation_ = new BoundedCorrelation(boundedCorrelationNode);
             }
         }
         else
         {
             boundedCorrelation_ = new BoundedCorrelation(boundedCorrelationNode);
         }
     }
     
 
     XmlNode numberOfDataSeriesNode = xmlNode.SelectSingleNode("numberOfDataSeries");
     
     if (numberOfDataSeriesNode != null)
     {
         if (numberOfDataSeriesNode.Attributes["href"] != null || numberOfDataSeriesNode.Attributes["id"] != null) 
         {
             if (numberOfDataSeriesNode.Attributes["id"] != null) 
             {
                 numberOfDataSeriesIDRef_ = numberOfDataSeriesNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberOfDataSeriesNode);
                 IDManager.SetID(numberOfDataSeriesIDRef_, ob);
             }
             else if (numberOfDataSeriesNode.Attributes["href"] != null)
             {
                 numberOfDataSeriesIDRef_ = numberOfDataSeriesNode.Attributes["href"].Value;
             }
             else
             {
                 numberOfDataSeries_ = new XsdTypePositiveInteger(numberOfDataSeriesNode);
             }
         }
         else
         {
             numberOfDataSeries_ = new XsdTypePositiveInteger(numberOfDataSeriesNode);
         }
     }
     
 
 }
 public CommodityPricingDates(XmlNode xmlNode)
 {
     XmlNode calculationPeriodsReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsReference");
     
     if (calculationPeriodsReferenceNode != null)
     {
         if (calculationPeriodsReferenceNode.Attributes["href"] != null || calculationPeriodsReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsReferenceIDRef_ = calculationPeriodsReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsReference ob = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
                 IDManager.SetID(calculationPeriodsReferenceIDRef_, ob);
             }
             else if (calculationPeriodsReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsReferenceIDRef_ = calculationPeriodsReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsReference_ = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
             }
         }
         else
         {
             calculationPeriodsReference_ = new CalculationPeriodsReference(calculationPeriodsReferenceNode);
         }
     }
     
 
     XmlNode calculationPeriodsScheduleReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsScheduleReference");
     
     if (calculationPeriodsScheduleReferenceNode != null)
     {
         if (calculationPeriodsScheduleReferenceNode.Attributes["href"] != null || calculationPeriodsScheduleReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsScheduleReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsScheduleReferenceIDRef_ = calculationPeriodsScheduleReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsScheduleReference ob = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
                 IDManager.SetID(calculationPeriodsScheduleReferenceIDRef_, ob);
             }
             else if (calculationPeriodsScheduleReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsScheduleReferenceIDRef_ = calculationPeriodsScheduleReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsScheduleReference_ = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
             }
         }
         else
         {
             calculationPeriodsScheduleReference_ = new CalculationPeriodsScheduleReference(calculationPeriodsScheduleReferenceNode);
         }
     }
     
 
     XmlNode calculationPeriodsDatesReferenceNode = xmlNode.SelectSingleNode("calculationPeriodsDatesReference");
     
     if (calculationPeriodsDatesReferenceNode != null)
     {
         if (calculationPeriodsDatesReferenceNode.Attributes["href"] != null || calculationPeriodsDatesReferenceNode.Attributes["id"] != null) 
         {
             if (calculationPeriodsDatesReferenceNode.Attributes["id"] != null) 
             {
                 calculationPeriodsDatesReferenceIDRef_ = calculationPeriodsDatesReferenceNode.Attributes["id"].Value;
                 CalculationPeriodsDatesReference ob = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
                 IDManager.SetID(calculationPeriodsDatesReferenceIDRef_, ob);
             }
             else if (calculationPeriodsDatesReferenceNode.Attributes["href"] != null)
             {
                 calculationPeriodsDatesReferenceIDRef_ = calculationPeriodsDatesReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodsDatesReference_ = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
             }
         }
         else
         {
             calculationPeriodsDatesReference_ = new CalculationPeriodsDatesReference(calculationPeriodsDatesReferenceNode);
         }
     }
     
 
     XmlNode lagNode = xmlNode.SelectSingleNode("lag");
     
     if (lagNode != null)
     {
         if (lagNode.Attributes["href"] != null || lagNode.Attributes["id"] != null) 
         {
             if (lagNode.Attributes["id"] != null) 
             {
                 lagIDRef_ = lagNode.Attributes["id"].Value;
                 Lag ob = new Lag(lagNode);
                 IDManager.SetID(lagIDRef_, ob);
             }
             else if (lagNode.Attributes["href"] != null)
             {
                 lagIDRef_ = lagNode.Attributes["href"].Value;
             }
             else
             {
                 lag_ = new Lag(lagNode);
             }
         }
         else
         {
             lag_ = new Lag(lagNode);
         }
     }
     
 
     XmlNode dayTypeNode = xmlNode.SelectSingleNode("dayType");
     
     if (dayTypeNode != null)
     {
         if (dayTypeNode.Attributes["href"] != null || dayTypeNode.Attributes["id"] != null) 
         {
             if (dayTypeNode.Attributes["id"] != null) 
             {
                 dayTypeIDRef_ = dayTypeNode.Attributes["id"].Value;
                 CommodityDayTypeEnum ob = new CommodityDayTypeEnum(dayTypeNode);
                 IDManager.SetID(dayTypeIDRef_, ob);
             }
             else if (dayTypeNode.Attributes["href"] != null)
             {
                 dayTypeIDRef_ = dayTypeNode.Attributes["href"].Value;
             }
             else
             {
                 dayType_ = new CommodityDayTypeEnum(dayTypeNode);
             }
         }
         else
         {
             dayType_ = new CommodityDayTypeEnum(dayTypeNode);
         }
     }
     
 
     XmlNode dayDistributionNode = xmlNode.SelectSingleNode("dayDistribution");
     
     if (dayDistributionNode != null)
     {
         if (dayDistributionNode.Attributes["href"] != null || dayDistributionNode.Attributes["id"] != null) 
         {
             if (dayDistributionNode.Attributes["id"] != null) 
             {
                 dayDistributionIDRef_ = dayDistributionNode.Attributes["id"].Value;
                 CommodityFrequencyType ob = new CommodityFrequencyType(dayDistributionNode);
                 IDManager.SetID(dayDistributionIDRef_, ob);
             }
             else if (dayDistributionNode.Attributes["href"] != null)
             {
                 dayDistributionIDRef_ = dayDistributionNode.Attributes["href"].Value;
             }
             else
             {
                 dayDistribution_ = new CommodityFrequencyType(dayDistributionNode);
             }
         }
         else
         {
             dayDistribution_ = new CommodityFrequencyType(dayDistributionNode);
         }
     }
     
 
     XmlNode dayCountNode = xmlNode.SelectSingleNode("dayCount");
     
     if (dayCountNode != null)
     {
         if (dayCountNode.Attributes["href"] != null || dayCountNode.Attributes["id"] != null) 
         {
             if (dayCountNode.Attributes["id"] != null) 
             {
                 dayCountIDRef_ = dayCountNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(dayCountNode);
                 IDManager.SetID(dayCountIDRef_, ob);
             }
             else if (dayCountNode.Attributes["href"] != null)
             {
                 dayCountIDRef_ = dayCountNode.Attributes["href"].Value;
             }
             else
             {
                 dayCount_ = new XsdTypePositiveInteger(dayCountNode);
             }
         }
         else
         {
             dayCount_ = new XsdTypePositiveInteger(dayCountNode);
         }
     }
     
 
     XmlNodeList dayOfWeekNodeList = xmlNode.SelectNodes("dayOfWeek");
     
     if (dayOfWeekNodeList != null)
     {
         this.dayOfWeek_ = new List<DayOfWeekEnum>();
         foreach (XmlNode item in dayOfWeekNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     dayOfWeekIDRef_ = item.Attributes["id"].Value;
                     dayOfWeek_.Add(new DayOfWeekEnum(item));
                     IDManager.SetID(dayOfWeekIDRef_, dayOfWeek_[dayOfWeek_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     dayOfWeekIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 dayOfWeek_.Add(new DayOfWeekEnum(item));
                 }
             }
             else
             {
                 dayOfWeek_.Add(new DayOfWeekEnum(item));
             }
         }
     }
     
 
     XmlNode dayNumberNode = xmlNode.SelectSingleNode("dayNumber");
     
     if (dayNumberNode != null)
     {
         if (dayNumberNode.Attributes["href"] != null || dayNumberNode.Attributes["id"] != null) 
         {
             if (dayNumberNode.Attributes["id"] != null) 
             {
                 dayNumberIDRef_ = dayNumberNode.Attributes["id"].Value;
                 XsdTypeInteger ob = new XsdTypeInteger(dayNumberNode);
                 IDManager.SetID(dayNumberIDRef_, ob);
             }
             else if (dayNumberNode.Attributes["href"] != null)
             {
                 dayNumberIDRef_ = dayNumberNode.Attributes["href"].Value;
             }
             else
             {
                 dayNumber_ = new XsdTypeInteger(dayNumberNode);
             }
         }
         else
         {
             dayNumber_ = new XsdTypeInteger(dayNumberNode);
         }
     }
     
 
     XmlNode businessCalendarNode = xmlNode.SelectSingleNode("businessCalendar");
     
     if (businessCalendarNode != null)
     {
         if (businessCalendarNode.Attributes["href"] != null || businessCalendarNode.Attributes["id"] != null) 
         {
             if (businessCalendarNode.Attributes["id"] != null) 
             {
                 businessCalendarIDRef_ = businessCalendarNode.Attributes["id"].Value;
                 CommodityBusinessCalendar ob = new CommodityBusinessCalendar(businessCalendarNode);
                 IDManager.SetID(businessCalendarIDRef_, ob);
             }
             else if (businessCalendarNode.Attributes["href"] != null)
             {
                 businessCalendarIDRef_ = businessCalendarNode.Attributes["href"].Value;
             }
             else
             {
                 businessCalendar_ = new CommodityBusinessCalendar(businessCalendarNode);
             }
         }
         else
         {
             businessCalendar_ = new CommodityBusinessCalendar(businessCalendarNode);
         }
     }
     
 
     XmlNode calendarSourceNode = xmlNode.SelectSingleNode("calendarSource");
     
     if (calendarSourceNode != null)
     {
         if (calendarSourceNode.Attributes["href"] != null || calendarSourceNode.Attributes["id"] != null) 
         {
             if (calendarSourceNode.Attributes["id"] != null) 
             {
                 calendarSourceIDRef_ = calendarSourceNode.Attributes["id"].Value;
                 CalendarSourceEnum ob = new CalendarSourceEnum(calendarSourceNode);
                 IDManager.SetID(calendarSourceIDRef_, ob);
             }
             else if (calendarSourceNode.Attributes["href"] != null)
             {
                 calendarSourceIDRef_ = calendarSourceNode.Attributes["href"].Value;
             }
             else
             {
                 calendarSource_ = new CalendarSourceEnum(calendarSourceNode);
             }
         }
         else
         {
             calendarSource_ = new CalendarSourceEnum(calendarSourceNode);
         }
     }
     
 
     XmlNodeList settlementPeriodsNodeList = xmlNode.SelectNodes("settlementPeriods");
     
     if (settlementPeriodsNodeList != null)
     {
         this.settlementPeriods_ = new List<SettlementPeriods>();
         foreach (XmlNode item in settlementPeriodsNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     settlementPeriodsIDRef_ = item.Attributes["id"].Value;
                     settlementPeriods_.Add(new SettlementPeriods(item));
                     IDManager.SetID(settlementPeriodsIDRef_, settlementPeriods_[settlementPeriods_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     settlementPeriodsIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 settlementPeriods_.Add(new SettlementPeriods(item));
                 }
             }
             else
             {
                 settlementPeriods_.Add(new SettlementPeriods(item));
             }
         }
     }
     
 
     XmlNodeList settlementPeriodsReferenceNodeList = xmlNode.SelectNodes("settlementPeriodsReference");
     
     if (settlementPeriodsReferenceNodeList != null)
     {
         this.settlementPeriodsReference_ = new List<SettlementPeriodsReference>();
         foreach (XmlNode item in settlementPeriodsReferenceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     settlementPeriodsReferenceIDRef_ = item.Attributes["id"].Value;
                     settlementPeriodsReference_.Add(new SettlementPeriodsReference(item));
                     IDManager.SetID(settlementPeriodsReferenceIDRef_, settlementPeriodsReference_[settlementPeriodsReference_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     settlementPeriodsReferenceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 settlementPeriodsReference_.Add(new SettlementPeriodsReference(item));
                 }
             }
             else
             {
                 settlementPeriodsReference_.Add(new SettlementPeriodsReference(item));
             }
         }
     }
     
 
     XmlNodeList pricingDatesNodeList = xmlNode.SelectNodes("pricingDates");
     
     if (pricingDatesNodeList != null)
     {
         this.pricingDates_ = new List<AdjustableDates>();
         foreach (XmlNode item in pricingDatesNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     pricingDatesIDRef_ = item.Attributes["id"].Value;
                     pricingDates_.Add(new AdjustableDates(item));
                     IDManager.SetID(pricingDatesIDRef_, pricingDates_[pricingDates_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     pricingDatesIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 pricingDates_.Add(new AdjustableDates(item));
                 }
             }
             else
             {
                 pricingDates_.Add(new AdjustableDates(item));
             }
         }
     }
     
 
 }
 public CommodityMarketDisruption(XmlNode xmlNode)
 {
     XmlNode marketDisruptionEventsNode = xmlNode.SelectSingleNode("marketDisruptionEvents");
     
     if (marketDisruptionEventsNode != null)
     {
         if (marketDisruptionEventsNode.Attributes["href"] != null || marketDisruptionEventsNode.Attributes["id"] != null) 
         {
             if (marketDisruptionEventsNode.Attributes["id"] != null) 
             {
                 marketDisruptionEventsIDRef_ = marketDisruptionEventsNode.Attributes["id"].Value;
                 MarketDisruptionEventsEnum ob = new MarketDisruptionEventsEnum(marketDisruptionEventsNode);
                 IDManager.SetID(marketDisruptionEventsIDRef_, ob);
             }
             else if (marketDisruptionEventsNode.Attributes["href"] != null)
             {
                 marketDisruptionEventsIDRef_ = marketDisruptionEventsNode.Attributes["href"].Value;
             }
             else
             {
                 marketDisruptionEvents_ = new MarketDisruptionEventsEnum(marketDisruptionEventsNode);
             }
         }
         else
         {
             marketDisruptionEvents_ = new MarketDisruptionEventsEnum(marketDisruptionEventsNode);
         }
     }
     
 
     XmlNodeList additionalMarketDisruptionEventNodeList = xmlNode.SelectNodes("additionalMarketDisruptionEvent");
     
     if (additionalMarketDisruptionEventNodeList != null)
     {
         this.additionalMarketDisruptionEvent_ = new List<MarketDisruptionEvent>();
         foreach (XmlNode item in additionalMarketDisruptionEventNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     additionalMarketDisruptionEventIDRef_ = item.Attributes["id"].Value;
                     additionalMarketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
                     IDManager.SetID(additionalMarketDisruptionEventIDRef_, additionalMarketDisruptionEvent_[additionalMarketDisruptionEvent_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     additionalMarketDisruptionEventIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 additionalMarketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
                 }
             }
             else
             {
                 additionalMarketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNodeList marketDisruptionEventNodeList = xmlNode.SelectNodes("marketDisruptionEvent");
     
     if (marketDisruptionEventNodeList != null)
     {
         this.marketDisruptionEvent_ = new List<MarketDisruptionEvent>();
         foreach (XmlNode item in marketDisruptionEventNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     marketDisruptionEventIDRef_ = item.Attributes["id"].Value;
                     marketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
                     IDManager.SetID(marketDisruptionEventIDRef_, marketDisruptionEvent_[marketDisruptionEvent_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     marketDisruptionEventIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 marketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
                 }
             }
             else
             {
                 marketDisruptionEvent_.Add(new MarketDisruptionEvent(item));
             }
         }
     }
     
 
     XmlNode disruptionFallbacksNode = xmlNode.SelectSingleNode("disruptionFallbacks");
     
     if (disruptionFallbacksNode != null)
     {
         if (disruptionFallbacksNode.Attributes["href"] != null || disruptionFallbacksNode.Attributes["id"] != null) 
         {
             if (disruptionFallbacksNode.Attributes["id"] != null) 
             {
                 disruptionFallbacksIDRef_ = disruptionFallbacksNode.Attributes["id"].Value;
                 DisruptionFallbacksEnum ob = new DisruptionFallbacksEnum(disruptionFallbacksNode);
                 IDManager.SetID(disruptionFallbacksIDRef_, ob);
             }
             else if (disruptionFallbacksNode.Attributes["href"] != null)
             {
                 disruptionFallbacksIDRef_ = disruptionFallbacksNode.Attributes["href"].Value;
             }
             else
             {
                 disruptionFallbacks_ = new DisruptionFallbacksEnum(disruptionFallbacksNode);
             }
         }
         else
         {
             disruptionFallbacks_ = new DisruptionFallbacksEnum(disruptionFallbacksNode);
         }
     }
     
 
     XmlNodeList disruptionFallbackNodeList = xmlNode.SelectNodes("disruptionFallback");
     
     if (disruptionFallbackNodeList != null)
     {
         this.disruptionFallback_ = new List<SequencedDisruptionFallback>();
         foreach (XmlNode item in disruptionFallbackNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     disruptionFallbackIDRef_ = item.Attributes["id"].Value;
                     disruptionFallback_.Add(new SequencedDisruptionFallback(item));
                     IDManager.SetID(disruptionFallbackIDRef_, disruptionFallback_[disruptionFallback_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     disruptionFallbackIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 disruptionFallback_.Add(new SequencedDisruptionFallback(item));
                 }
             }
             else
             {
                 disruptionFallback_.Add(new SequencedDisruptionFallback(item));
             }
         }
     }
     
 
     XmlNode fallbackReferencePriceNode = xmlNode.SelectSingleNode("fallbackReferencePrice");
     
     if (fallbackReferencePriceNode != null)
     {
         if (fallbackReferencePriceNode.Attributes["href"] != null || fallbackReferencePriceNode.Attributes["id"] != null) 
         {
             if (fallbackReferencePriceNode.Attributes["id"] != null) 
             {
                 fallbackReferencePriceIDRef_ = fallbackReferencePriceNode.Attributes["id"].Value;
                 Underlyer ob = new Underlyer(fallbackReferencePriceNode);
                 IDManager.SetID(fallbackReferencePriceIDRef_, ob);
             }
             else if (fallbackReferencePriceNode.Attributes["href"] != null)
             {
                 fallbackReferencePriceIDRef_ = fallbackReferencePriceNode.Attributes["href"].Value;
             }
             else
             {
                 fallbackReferencePrice_ = new Underlyer(fallbackReferencePriceNode);
             }
         }
         else
         {
             fallbackReferencePrice_ = new Underlyer(fallbackReferencePriceNode);
         }
     }
     
 
     XmlNode maximumNumberOfDaysOfDisruptionNode = xmlNode.SelectSingleNode("maximumNumberOfDaysOfDisruption");
     
     if (maximumNumberOfDaysOfDisruptionNode != null)
     {
         if (maximumNumberOfDaysOfDisruptionNode.Attributes["href"] != null || maximumNumberOfDaysOfDisruptionNode.Attributes["id"] != null) 
         {
             if (maximumNumberOfDaysOfDisruptionNode.Attributes["id"] != null) 
             {
                 maximumNumberOfDaysOfDisruptionIDRef_ = maximumNumberOfDaysOfDisruptionNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(maximumNumberOfDaysOfDisruptionNode);
                 IDManager.SetID(maximumNumberOfDaysOfDisruptionIDRef_, ob);
             }
             else if (maximumNumberOfDaysOfDisruptionNode.Attributes["href"] != null)
             {
                 maximumNumberOfDaysOfDisruptionIDRef_ = maximumNumberOfDaysOfDisruptionNode.Attributes["href"].Value;
             }
             else
             {
                 maximumNumberOfDaysOfDisruption_ = new XsdTypeNonNegativeInteger(maximumNumberOfDaysOfDisruptionNode);
             }
         }
         else
         {
             maximumNumberOfDaysOfDisruption_ = new XsdTypeNonNegativeInteger(maximumNumberOfDaysOfDisruptionNode);
         }
     }
     
 
     XmlNode priceMaterialityPercentageNode = xmlNode.SelectSingleNode("priceMaterialityPercentage");
     
     if (priceMaterialityPercentageNode != null)
     {
         if (priceMaterialityPercentageNode.Attributes["href"] != null || priceMaterialityPercentageNode.Attributes["id"] != null) 
         {
             if (priceMaterialityPercentageNode.Attributes["id"] != null) 
             {
                 priceMaterialityPercentageIDRef_ = priceMaterialityPercentageNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(priceMaterialityPercentageNode);
                 IDManager.SetID(priceMaterialityPercentageIDRef_, ob);
             }
             else if (priceMaterialityPercentageNode.Attributes["href"] != null)
             {
                 priceMaterialityPercentageIDRef_ = priceMaterialityPercentageNode.Attributes["href"].Value;
             }
             else
             {
                 priceMaterialityPercentage_ = new XsdTypeDecimal(priceMaterialityPercentageNode);
             }
         }
         else
         {
             priceMaterialityPercentage_ = new XsdTypeDecimal(priceMaterialityPercentageNode);
         }
     }
     
 
     XmlNode minimumFuturesContractsNode = xmlNode.SelectSingleNode("minimumFuturesContracts");
     
     if (minimumFuturesContractsNode != null)
     {
         if (minimumFuturesContractsNode.Attributes["href"] != null || minimumFuturesContractsNode.Attributes["id"] != null) 
         {
             if (minimumFuturesContractsNode.Attributes["id"] != null) 
             {
                 minimumFuturesContractsIDRef_ = minimumFuturesContractsNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(minimumFuturesContractsNode);
                 IDManager.SetID(minimumFuturesContractsIDRef_, ob);
             }
             else if (minimumFuturesContractsNode.Attributes["href"] != null)
             {
                 minimumFuturesContractsIDRef_ = minimumFuturesContractsNode.Attributes["href"].Value;
             }
             else
             {
                 minimumFuturesContracts_ = new XsdTypePositiveInteger(minimumFuturesContractsNode);
             }
         }
         else
         {
             minimumFuturesContracts_ = new XsdTypePositiveInteger(minimumFuturesContractsNode);
         }
     }
     
 
 }
 public Position(XmlNode xmlNode)
 {
     XmlNode positionIdNode = xmlNode.SelectSingleNode("positionId");
     
     if (positionIdNode != null)
     {
         if (positionIdNode.Attributes["href"] != null || positionIdNode.Attributes["id"] != null) 
         {
             if (positionIdNode.Attributes["id"] != null) 
             {
                 positionIdIDRef_ = positionIdNode.Attributes["id"].Value;
                 PositionId ob = new PositionId(positionIdNode);
                 IDManager.SetID(positionIdIDRef_, ob);
             }
             else if (positionIdNode.Attributes["href"] != null)
             {
                 positionIdIDRef_ = positionIdNode.Attributes["href"].Value;
             }
             else
             {
                 positionId_ = new PositionId(positionIdNode);
             }
         }
         else
         {
             positionId_ = new PositionId(positionIdNode);
         }
     }
     
 
     XmlNode versionNode = xmlNode.SelectSingleNode("version");
     
     if (versionNode != null)
     {
         if (versionNode.Attributes["href"] != null || versionNode.Attributes["id"] != null) 
         {
             if (versionNode.Attributes["id"] != null) 
             {
                 versionIDRef_ = versionNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(versionNode);
                 IDManager.SetID(versionIDRef_, ob);
             }
             else if (versionNode.Attributes["href"] != null)
             {
                 versionIDRef_ = versionNode.Attributes["href"].Value;
             }
             else
             {
                 version_ = new XsdTypePositiveInteger(versionNode);
             }
         }
         else
         {
             version_ = new XsdTypePositiveInteger(versionNode);
         }
     }
     
 
     XmlNode statusNode = xmlNode.SelectSingleNode("status");
     
     if (statusNode != null)
     {
         if (statusNode.Attributes["href"] != null || statusNode.Attributes["id"] != null) 
         {
             if (statusNode.Attributes["id"] != null) 
             {
                 statusIDRef_ = statusNode.Attributes["id"].Value;
                 PositionStatusEnum ob = new PositionStatusEnum(statusNode);
                 IDManager.SetID(statusIDRef_, ob);
             }
             else if (statusNode.Attributes["href"] != null)
             {
                 statusIDRef_ = statusNode.Attributes["href"].Value;
             }
             else
             {
                 status_ = new PositionStatusEnum(statusNode);
             }
         }
         else
         {
             status_ = new PositionStatusEnum(statusNode);
         }
     }
     
 
     XmlNode creationDateNode = xmlNode.SelectSingleNode("creationDate");
     
     if (creationDateNode != null)
     {
         if (creationDateNode.Attributes["href"] != null || creationDateNode.Attributes["id"] != null) 
         {
             if (creationDateNode.Attributes["id"] != null) 
             {
                 creationDateIDRef_ = creationDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(creationDateNode);
                 IDManager.SetID(creationDateIDRef_, ob);
             }
             else if (creationDateNode.Attributes["href"] != null)
             {
                 creationDateIDRef_ = creationDateNode.Attributes["href"].Value;
             }
             else
             {
                 creationDate_ = new XsdTypeDate(creationDateNode);
             }
         }
         else
         {
             creationDate_ = new XsdTypeDate(creationDateNode);
         }
     }
     
 
     XmlNode originatingEventNode = xmlNode.SelectSingleNode("originatingEvent");
     
     if (originatingEventNode != null)
     {
         if (originatingEventNode.Attributes["href"] != null || originatingEventNode.Attributes["id"] != null) 
         {
             if (originatingEventNode.Attributes["id"] != null) 
             {
                 originatingEventIDRef_ = originatingEventNode.Attributes["id"].Value;
                 PositionOriginEnum ob = new PositionOriginEnum(originatingEventNode);
                 IDManager.SetID(originatingEventIDRef_, ob);
             }
             else if (originatingEventNode.Attributes["href"] != null)
             {
                 originatingEventIDRef_ = originatingEventNode.Attributes["href"].Value;
             }
             else
             {
                 originatingEvent_ = new PositionOriginEnum(originatingEventNode);
             }
         }
         else
         {
             originatingEvent_ = new PositionOriginEnum(originatingEventNode);
         }
     }
     
 
     XmlNode historyNode = xmlNode.SelectSingleNode("history");
     
     if (historyNode != null)
     {
         if (historyNode.Attributes["href"] != null || historyNode.Attributes["id"] != null) 
         {
             if (historyNode.Attributes["id"] != null) 
             {
                 historyIDRef_ = historyNode.Attributes["id"].Value;
                 PositionHistory ob = new PositionHistory(historyNode);
                 IDManager.SetID(historyIDRef_, ob);
             }
             else if (historyNode.Attributes["href"] != null)
             {
                 historyIDRef_ = historyNode.Attributes["href"].Value;
             }
             else
             {
                 history_ = new PositionHistory(historyNode);
             }
         }
         else
         {
             history_ = new PositionHistory(historyNode);
         }
     }
     
 
     XmlNode reportingRolesNode = xmlNode.SelectSingleNode("reportingRoles");
     
     if (reportingRolesNode != null)
     {
         if (reportingRolesNode.Attributes["href"] != null || reportingRolesNode.Attributes["id"] != null) 
         {
             if (reportingRolesNode.Attributes["id"] != null) 
             {
                 reportingRolesIDRef_ = reportingRolesNode.Attributes["id"].Value;
                 ReportingRoles ob = new ReportingRoles(reportingRolesNode);
                 IDManager.SetID(reportingRolesIDRef_, ob);
             }
             else if (reportingRolesNode.Attributes["href"] != null)
             {
                 reportingRolesIDRef_ = reportingRolesNode.Attributes["href"].Value;
             }
             else
             {
                 reportingRoles_ = new ReportingRoles(reportingRolesNode);
             }
         }
         else
         {
             reportingRoles_ = new ReportingRoles(reportingRolesNode);
         }
     }
     
 
     XmlNode constituentNode = xmlNode.SelectSingleNode("constituent");
     
     if (constituentNode != null)
     {
         if (constituentNode.Attributes["href"] != null || constituentNode.Attributes["id"] != null) 
         {
             if (constituentNode.Attributes["id"] != null) 
             {
                 constituentIDRef_ = constituentNode.Attributes["id"].Value;
                 PositionConstituent ob = new PositionConstituent(constituentNode);
                 IDManager.SetID(constituentIDRef_, ob);
             }
             else if (constituentNode.Attributes["href"] != null)
             {
                 constituentIDRef_ = constituentNode.Attributes["href"].Value;
             }
             else
             {
                 constituent_ = new PositionConstituent(constituentNode);
             }
         }
         else
         {
             constituent_ = new PositionConstituent(constituentNode);
         }
     }
     
 
     XmlNodeList scheduledDateNodeList = xmlNode.SelectNodes("scheduledDate");
     
     if (scheduledDateNodeList != null)
     {
         this.scheduledDate_ = new List<ScheduledDate>();
         foreach (XmlNode item in scheduledDateNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     scheduledDateIDRef_ = item.Attributes["id"].Value;
                     scheduledDate_.Add(new ScheduledDate(item));
                     IDManager.SetID(scheduledDateIDRef_, scheduledDate_[scheduledDate_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     scheduledDateIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 scheduledDate_.Add(new ScheduledDate(item));
                 }
             }
             else
             {
                 scheduledDate_.Add(new ScheduledDate(item));
             }
         }
     }
     
 
     XmlNodeList valuationNodeList = xmlNode.SelectNodes("valuation");
     
     if (valuationNodeList != null)
     {
         this.valuation_ = new List<AssetValuation>();
         foreach (XmlNode item in valuationNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     valuationIDRef_ = item.Attributes["id"].Value;
                     valuation_.Add(new AssetValuation(item));
                     IDManager.SetID(valuationIDRef_, valuation_[valuation_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     valuationIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 valuation_.Add(new AssetValuation(item));
                 }
             }
             else
             {
                 valuation_.Add(new AssetValuation(item));
             }
         }
     }
     
 
 }
 public BasketReferenceInformation(XmlNode xmlNode)
 {
     XmlNode basketNameNode = xmlNode.SelectSingleNode("basketName");
     
     if (basketNameNode != null)
     {
         if (basketNameNode.Attributes["href"] != null || basketNameNode.Attributes["id"] != null) 
         {
             if (basketNameNode.Attributes["id"] != null) 
             {
                 basketNameIDRef_ = basketNameNode.Attributes["id"].Value;
                 BasketName ob = new BasketName(basketNameNode);
                 IDManager.SetID(basketNameIDRef_, ob);
             }
             else if (basketNameNode.Attributes["href"] != null)
             {
                 basketNameIDRef_ = basketNameNode.Attributes["href"].Value;
             }
             else
             {
                 basketName_ = new BasketName(basketNameNode);
             }
         }
         else
         {
             basketName_ = new BasketName(basketNameNode);
         }
     }
     
 
     XmlNodeList basketIdNodeList = xmlNode.SelectNodes("basketId");
     
     if (basketIdNodeList != null)
     {
         this.basketId_ = new List<BasketId>();
         foreach (XmlNode item in basketIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     basketIdIDRef_ = item.Attributes["id"].Value;
                     basketId_.Add(new BasketId(item));
                     IDManager.SetID(basketIdIDRef_, basketId_[basketId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     basketIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 basketId_.Add(new BasketId(item));
                 }
             }
             else
             {
                 basketId_.Add(new BasketId(item));
             }
         }
     }
     
 
     XmlNode referencePoolNode = xmlNode.SelectSingleNode("referencePool");
     
     if (referencePoolNode != null)
     {
         if (referencePoolNode.Attributes["href"] != null || referencePoolNode.Attributes["id"] != null) 
         {
             if (referencePoolNode.Attributes["id"] != null) 
             {
                 referencePoolIDRef_ = referencePoolNode.Attributes["id"].Value;
                 ReferencePool ob = new ReferencePool(referencePoolNode);
                 IDManager.SetID(referencePoolIDRef_, ob);
             }
             else if (referencePoolNode.Attributes["href"] != null)
             {
                 referencePoolIDRef_ = referencePoolNode.Attributes["href"].Value;
             }
             else
             {
                 referencePool_ = new ReferencePool(referencePoolNode);
             }
         }
         else
         {
             referencePool_ = new ReferencePool(referencePoolNode);
         }
     }
     
 
     XmlNode nthToDefaultNode = xmlNode.SelectSingleNode("nthToDefault");
     
     if (nthToDefaultNode != null)
     {
         if (nthToDefaultNode.Attributes["href"] != null || nthToDefaultNode.Attributes["id"] != null) 
         {
             if (nthToDefaultNode.Attributes["id"] != null) 
             {
                 nthToDefaultIDRef_ = nthToDefaultNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(nthToDefaultNode);
                 IDManager.SetID(nthToDefaultIDRef_, ob);
             }
             else if (nthToDefaultNode.Attributes["href"] != null)
             {
                 nthToDefaultIDRef_ = nthToDefaultNode.Attributes["href"].Value;
             }
             else
             {
                 nthToDefault_ = new XsdTypePositiveInteger(nthToDefaultNode);
             }
         }
         else
         {
             nthToDefault_ = new XsdTypePositiveInteger(nthToDefaultNode);
         }
     }
     
 
     XmlNode mthToDefaultNode = xmlNode.SelectSingleNode("mthToDefault");
     
     if (mthToDefaultNode != null)
     {
         if (mthToDefaultNode.Attributes["href"] != null || mthToDefaultNode.Attributes["id"] != null) 
         {
             if (mthToDefaultNode.Attributes["id"] != null) 
             {
                 mthToDefaultIDRef_ = mthToDefaultNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(mthToDefaultNode);
                 IDManager.SetID(mthToDefaultIDRef_, ob);
             }
             else if (mthToDefaultNode.Attributes["href"] != null)
             {
                 mthToDefaultIDRef_ = mthToDefaultNode.Attributes["href"].Value;
             }
             else
             {
                 mthToDefault_ = new XsdTypePositiveInteger(mthToDefaultNode);
             }
         }
         else
         {
             mthToDefault_ = new XsdTypePositiveInteger(mthToDefaultNode);
         }
     }
     
 
     XmlNode trancheNode = xmlNode.SelectSingleNode("tranche");
     
     if (trancheNode != null)
     {
         if (trancheNode.Attributes["href"] != null || trancheNode.Attributes["id"] != null) 
         {
             if (trancheNode.Attributes["id"] != null) 
             {
                 trancheIDRef_ = trancheNode.Attributes["id"].Value;
                 Tranche ob = new Tranche(trancheNode);
                 IDManager.SetID(trancheIDRef_, ob);
             }
             else if (trancheNode.Attributes["href"] != null)
             {
                 trancheIDRef_ = trancheNode.Attributes["href"].Value;
             }
             else
             {
                 tranche_ = new Tranche(trancheNode);
             }
         }
         else
         {
             tranche_ = new Tranche(trancheNode);
         }
     }
     
 
 }
 public CalculationFromObservation(XmlNode xmlNode)
 {
     XmlNode initialLevelNode = xmlNode.SelectSingleNode("initialLevel");
     
     if (initialLevelNode != null)
     {
         if (initialLevelNode.Attributes["href"] != null || initialLevelNode.Attributes["id"] != null) 
         {
             if (initialLevelNode.Attributes["id"] != null) 
             {
                 initialLevelIDRef_ = initialLevelNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(initialLevelNode);
                 IDManager.SetID(initialLevelIDRef_, ob);
             }
             else if (initialLevelNode.Attributes["href"] != null)
             {
                 initialLevelIDRef_ = initialLevelNode.Attributes["href"].Value;
             }
             else
             {
                 initialLevel_ = new XsdTypeDecimal(initialLevelNode);
             }
         }
         else
         {
             initialLevel_ = new XsdTypeDecimal(initialLevelNode);
         }
     }
     
 
     XmlNode closingLevelNode = xmlNode.SelectSingleNode("closingLevel");
     
     if (closingLevelNode != null)
     {
         if (closingLevelNode.Attributes["href"] != null || closingLevelNode.Attributes["id"] != null) 
         {
             if (closingLevelNode.Attributes["id"] != null) 
             {
                 closingLevelIDRef_ = closingLevelNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(closingLevelNode);
                 IDManager.SetID(closingLevelIDRef_, ob);
             }
             else if (closingLevelNode.Attributes["href"] != null)
             {
                 closingLevelIDRef_ = closingLevelNode.Attributes["href"].Value;
             }
             else
             {
                 closingLevel_ = new XsdTypeBoolean(closingLevelNode);
             }
         }
         else
         {
             closingLevel_ = new XsdTypeBoolean(closingLevelNode);
         }
     }
     
 
     XmlNode expiringLevelNode = xmlNode.SelectSingleNode("expiringLevel");
     
     if (expiringLevelNode != null)
     {
         if (expiringLevelNode.Attributes["href"] != null || expiringLevelNode.Attributes["id"] != null) 
         {
             if (expiringLevelNode.Attributes["id"] != null) 
             {
                 expiringLevelIDRef_ = expiringLevelNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(expiringLevelNode);
                 IDManager.SetID(expiringLevelIDRef_, ob);
             }
             else if (expiringLevelNode.Attributes["href"] != null)
             {
                 expiringLevelIDRef_ = expiringLevelNode.Attributes["href"].Value;
             }
             else
             {
                 expiringLevel_ = new XsdTypeBoolean(expiringLevelNode);
             }
         }
         else
         {
             expiringLevel_ = new XsdTypeBoolean(expiringLevelNode);
         }
     }
     
 
     XmlNode expectedNNode = xmlNode.SelectSingleNode("expectedN");
     
     if (expectedNNode != null)
     {
         if (expectedNNode.Attributes["href"] != null || expectedNNode.Attributes["id"] != null) 
         {
             if (expectedNNode.Attributes["id"] != null) 
             {
                 expectedNIDRef_ = expectedNNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(expectedNNode);
                 IDManager.SetID(expectedNIDRef_, ob);
             }
             else if (expectedNNode.Attributes["href"] != null)
             {
                 expectedNIDRef_ = expectedNNode.Attributes["href"].Value;
             }
             else
             {
                 expectedN_ = new XsdTypePositiveInteger(expectedNNode);
             }
         }
         else
         {
             expectedN_ = new XsdTypePositiveInteger(expectedNNode);
         }
     }
     
 
 }
        public Position(XmlNode xmlNode)
        {
            XmlNode positionIdNode = xmlNode.SelectSingleNode("positionId");

            if (positionIdNode != null)
            {
                if (positionIdNode.Attributes["href"] != null || positionIdNode.Attributes["id"] != null)
                {
                    if (positionIdNode.Attributes["id"] != null)
                    {
                        positionIdIDRef_ = positionIdNode.Attributes["id"].Value;
                        PositionId ob = new PositionId(positionIdNode);
                        IDManager.SetID(positionIdIDRef_, ob);
                    }
                    else if (positionIdNode.Attributes["href"] != null)
                    {
                        positionIdIDRef_ = positionIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        positionId_ = new PositionId(positionIdNode);
                    }
                }
                else
                {
                    positionId_ = new PositionId(positionIdNode);
                }
            }


            XmlNode versionNode = xmlNode.SelectSingleNode("version");

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


            XmlNode statusNode = xmlNode.SelectSingleNode("status");

            if (statusNode != null)
            {
                if (statusNode.Attributes["href"] != null || statusNode.Attributes["id"] != null)
                {
                    if (statusNode.Attributes["id"] != null)
                    {
                        statusIDRef_ = statusNode.Attributes["id"].Value;
                        PositionStatusEnum ob = new PositionStatusEnum(statusNode);
                        IDManager.SetID(statusIDRef_, ob);
                    }
                    else if (statusNode.Attributes["href"] != null)
                    {
                        statusIDRef_ = statusNode.Attributes["href"].Value;
                    }
                    else
                    {
                        status_ = new PositionStatusEnum(statusNode);
                    }
                }
                else
                {
                    status_ = new PositionStatusEnum(statusNode);
                }
            }


            XmlNode creationDateNode = xmlNode.SelectSingleNode("creationDate");

            if (creationDateNode != null)
            {
                if (creationDateNode.Attributes["href"] != null || creationDateNode.Attributes["id"] != null)
                {
                    if (creationDateNode.Attributes["id"] != null)
                    {
                        creationDateIDRef_ = creationDateNode.Attributes["id"].Value;
                        XsdTypeDate ob = new XsdTypeDate(creationDateNode);
                        IDManager.SetID(creationDateIDRef_, ob);
                    }
                    else if (creationDateNode.Attributes["href"] != null)
                    {
                        creationDateIDRef_ = creationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        creationDate_ = new XsdTypeDate(creationDateNode);
                    }
                }
                else
                {
                    creationDate_ = new XsdTypeDate(creationDateNode);
                }
            }


            XmlNode originatingEventNode = xmlNode.SelectSingleNode("originatingEvent");

            if (originatingEventNode != null)
            {
                if (originatingEventNode.Attributes["href"] != null || originatingEventNode.Attributes["id"] != null)
                {
                    if (originatingEventNode.Attributes["id"] != null)
                    {
                        originatingEventIDRef_ = originatingEventNode.Attributes["id"].Value;
                        PositionOriginEnum ob = new PositionOriginEnum(originatingEventNode);
                        IDManager.SetID(originatingEventIDRef_, ob);
                    }
                    else if (originatingEventNode.Attributes["href"] != null)
                    {
                        originatingEventIDRef_ = originatingEventNode.Attributes["href"].Value;
                    }
                    else
                    {
                        originatingEvent_ = new PositionOriginEnum(originatingEventNode);
                    }
                }
                else
                {
                    originatingEvent_ = new PositionOriginEnum(originatingEventNode);
                }
            }


            XmlNode historyNode = xmlNode.SelectSingleNode("history");

            if (historyNode != null)
            {
                if (historyNode.Attributes["href"] != null || historyNode.Attributes["id"] != null)
                {
                    if (historyNode.Attributes["id"] != null)
                    {
                        historyIDRef_ = historyNode.Attributes["id"].Value;
                        PositionHistory ob = new PositionHistory(historyNode);
                        IDManager.SetID(historyIDRef_, ob);
                    }
                    else if (historyNode.Attributes["href"] != null)
                    {
                        historyIDRef_ = historyNode.Attributes["href"].Value;
                    }
                    else
                    {
                        history_ = new PositionHistory(historyNode);
                    }
                }
                else
                {
                    history_ = new PositionHistory(historyNode);
                }
            }


            XmlNode reportingRolesNode = xmlNode.SelectSingleNode("reportingRoles");

            if (reportingRolesNode != null)
            {
                if (reportingRolesNode.Attributes["href"] != null || reportingRolesNode.Attributes["id"] != null)
                {
                    if (reportingRolesNode.Attributes["id"] != null)
                    {
                        reportingRolesIDRef_ = reportingRolesNode.Attributes["id"].Value;
                        ReportingRoles ob = new ReportingRoles(reportingRolesNode);
                        IDManager.SetID(reportingRolesIDRef_, ob);
                    }
                    else if (reportingRolesNode.Attributes["href"] != null)
                    {
                        reportingRolesIDRef_ = reportingRolesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        reportingRoles_ = new ReportingRoles(reportingRolesNode);
                    }
                }
                else
                {
                    reportingRoles_ = new ReportingRoles(reportingRolesNode);
                }
            }


            XmlNode constituentNode = xmlNode.SelectSingleNode("constituent");

            if (constituentNode != null)
            {
                if (constituentNode.Attributes["href"] != null || constituentNode.Attributes["id"] != null)
                {
                    if (constituentNode.Attributes["id"] != null)
                    {
                        constituentIDRef_ = constituentNode.Attributes["id"].Value;
                        PositionConstituent ob = new PositionConstituent(constituentNode);
                        IDManager.SetID(constituentIDRef_, ob);
                    }
                    else if (constituentNode.Attributes["href"] != null)
                    {
                        constituentIDRef_ = constituentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        constituent_ = new PositionConstituent(constituentNode);
                    }
                }
                else
                {
                    constituent_ = new PositionConstituent(constituentNode);
                }
            }


            XmlNodeList scheduledDateNodeList = xmlNode.SelectNodes("scheduledDate");

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


            XmlNodeList valuationNodeList = xmlNode.SelectNodes("valuation");

            if (valuationNodeList != null)
            {
                this.valuation_ = new List <AssetValuation>();
                foreach (XmlNode item in valuationNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            valuationIDRef_ = item.Attributes["id"].Value;
                            valuation_.Add(new AssetValuation(item));
                            IDManager.SetID(valuationIDRef_, valuation_[valuation_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            valuationIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            valuation_.Add(new AssetValuation(item));
                        }
                    }
                    else
                    {
                        valuation_.Add(new AssetValuation(item));
                    }
                }
            }
        }
Beispiel #45
0
        public IntermediaryInformation(XmlNode xmlNode)
        {
            XmlNodeList routingIdsNodeList = xmlNode.SelectNodes("routingIds");

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

            foreach (XmlNode item in routingIdsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        routingIdsIDRef = item.Attributes["id"].Name;
                        RoutingIds ob = RoutingIds();
                        IDManager.SetID(routingIdsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        routingIdsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        routingIds = new RoutingIds(item);
                    }
                }
            }


            XmlNodeList routingExplicitDetailsNodeList = xmlNode.SelectNodes("routingExplicitDetails");

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

            foreach (XmlNode item in routingExplicitDetailsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        routingExplicitDetailsIDRef = item.Attributes["id"].Name;
                        RoutingExplicitDetails ob = RoutingExplicitDetails();
                        IDManager.SetID(routingExplicitDetailsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        routingExplicitDetailsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        routingExplicitDetails = new RoutingExplicitDetails(item);
                    }
                }
            }


            XmlNodeList routingIdsAndExplicitDetailsNodeList = xmlNode.SelectNodes("routingIdsAndExplicitDetails");

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

            foreach (XmlNode item in routingIdsAndExplicitDetailsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        routingIdsAndExplicitDetailsIDRef = item.Attributes["id"].Name;
                        RoutingIdsAndExplicitDetails ob = RoutingIdsAndExplicitDetails();
                        IDManager.SetID(routingIdsAndExplicitDetailsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        routingIdsAndExplicitDetailsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        routingIdsAndExplicitDetails = new RoutingIdsAndExplicitDetails(item);
                    }
                }
            }


            XmlNodeList intermediarySequenceNumberNodeList = xmlNode.SelectNodes("intermediarySequenceNumber");

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

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


            XmlNodeList intermediaryPartyReferenceNodeList = xmlNode.SelectNodes("intermediaryPartyReference");

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

            foreach (XmlNode item in intermediaryPartyReferenceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        intermediaryPartyReferenceIDRef = item.Attributes["id"].Name;
                        PartyReference ob = PartyReference();
                        IDManager.SetID(intermediaryPartyReferenceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        intermediaryPartyReferenceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        intermediaryPartyReference = new PartyReference(item);
                    }
                }
            }
        }
 public Fra(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode buyerPartyReferenceNode = xmlNode.SelectSingleNode("buyerPartyReference");
     
     if (buyerPartyReferenceNode != null)
     {
         if (buyerPartyReferenceNode.Attributes["href"] != null || buyerPartyReferenceNode.Attributes["id"] != null) 
         {
             if (buyerPartyReferenceNode.Attributes["id"] != null) 
             {
                 buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["id"].Value;
                 PartyReference ob = new PartyReference(buyerPartyReferenceNode);
                 IDManager.SetID(buyerPartyReferenceIDRef_, ob);
             }
             else if (buyerPartyReferenceNode.Attributes["href"] != null)
             {
                 buyerPartyReferenceIDRef_ = buyerPartyReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
             }
         }
         else
         {
             buyerPartyReference_ = new PartyReference(buyerPartyReferenceNode);
         }
     }
     
 
     XmlNode buyerAccountReferenceNode = xmlNode.SelectSingleNode("buyerAccountReference");
     
     if (buyerAccountReferenceNode != null)
     {
         if (buyerAccountReferenceNode.Attributes["href"] != null || buyerAccountReferenceNode.Attributes["id"] != null) 
         {
             if (buyerAccountReferenceNode.Attributes["id"] != null) 
             {
                 buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["id"].Value;
                 AccountReference ob = new AccountReference(buyerAccountReferenceNode);
                 IDManager.SetID(buyerAccountReferenceIDRef_, ob);
             }
             else if (buyerAccountReferenceNode.Attributes["href"] != null)
             {
                 buyerAccountReferenceIDRef_ = buyerAccountReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
             }
         }
         else
         {
             buyerAccountReference_ = new AccountReference(buyerAccountReferenceNode);
         }
     }
     
 
     XmlNode sellerPartyReferenceNode = xmlNode.SelectSingleNode("sellerPartyReference");
     
     if (sellerPartyReferenceNode != null)
     {
         if (sellerPartyReferenceNode.Attributes["href"] != null || sellerPartyReferenceNode.Attributes["id"] != null) 
         {
             if (sellerPartyReferenceNode.Attributes["id"] != null) 
             {
                 sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["id"].Value;
                 PartyReference ob = new PartyReference(sellerPartyReferenceNode);
                 IDManager.SetID(sellerPartyReferenceIDRef_, ob);
             }
             else if (sellerPartyReferenceNode.Attributes["href"] != null)
             {
                 sellerPartyReferenceIDRef_ = sellerPartyReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
             }
         }
         else
         {
             sellerPartyReference_ = new PartyReference(sellerPartyReferenceNode);
         }
     }
     
 
     XmlNode sellerAccountReferenceNode = xmlNode.SelectSingleNode("sellerAccountReference");
     
     if (sellerAccountReferenceNode != null)
     {
         if (sellerAccountReferenceNode.Attributes["href"] != null || sellerAccountReferenceNode.Attributes["id"] != null) 
         {
             if (sellerAccountReferenceNode.Attributes["id"] != null) 
             {
                 sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["id"].Value;
                 AccountReference ob = new AccountReference(sellerAccountReferenceNode);
                 IDManager.SetID(sellerAccountReferenceIDRef_, ob);
             }
             else if (sellerAccountReferenceNode.Attributes["href"] != null)
             {
                 sellerAccountReferenceIDRef_ = sellerAccountReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
             }
         }
         else
         {
             sellerAccountReference_ = new AccountReference(sellerAccountReferenceNode);
         }
     }
     
 
     XmlNode adjustedEffectiveDateNode = xmlNode.SelectSingleNode("adjustedEffectiveDate");
     
     if (adjustedEffectiveDateNode != null)
     {
         if (adjustedEffectiveDateNode.Attributes["href"] != null || adjustedEffectiveDateNode.Attributes["id"] != null) 
         {
             if (adjustedEffectiveDateNode.Attributes["id"] != null) 
             {
                 adjustedEffectiveDateIDRef_ = adjustedEffectiveDateNode.Attributes["id"].Value;
                 RequiredIdentifierDate ob = new RequiredIdentifierDate(adjustedEffectiveDateNode);
                 IDManager.SetID(adjustedEffectiveDateIDRef_, ob);
             }
             else if (adjustedEffectiveDateNode.Attributes["href"] != null)
             {
                 adjustedEffectiveDateIDRef_ = adjustedEffectiveDateNode.Attributes["href"].Value;
             }
             else
             {
                 adjustedEffectiveDate_ = new RequiredIdentifierDate(adjustedEffectiveDateNode);
             }
         }
         else
         {
             adjustedEffectiveDate_ = new RequiredIdentifierDate(adjustedEffectiveDateNode);
         }
     }
     
 
     XmlNode adjustedTerminationDateNode = xmlNode.SelectSingleNode("adjustedTerminationDate");
     
     if (adjustedTerminationDateNode != null)
     {
         if (adjustedTerminationDateNode.Attributes["href"] != null || adjustedTerminationDateNode.Attributes["id"] != null) 
         {
             if (adjustedTerminationDateNode.Attributes["id"] != null) 
             {
                 adjustedTerminationDateIDRef_ = adjustedTerminationDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(adjustedTerminationDateNode);
                 IDManager.SetID(adjustedTerminationDateIDRef_, ob);
             }
             else if (adjustedTerminationDateNode.Attributes["href"] != null)
             {
                 adjustedTerminationDateIDRef_ = adjustedTerminationDateNode.Attributes["href"].Value;
             }
             else
             {
                 adjustedTerminationDate_ = new XsdTypeDate(adjustedTerminationDateNode);
             }
         }
         else
         {
             adjustedTerminationDate_ = new XsdTypeDate(adjustedTerminationDateNode);
         }
     }
     
 
     XmlNode paymentDateNode = xmlNode.SelectSingleNode("paymentDate");
     
     if (paymentDateNode != null)
     {
         if (paymentDateNode.Attributes["href"] != null || paymentDateNode.Attributes["id"] != null) 
         {
             if (paymentDateNode.Attributes["id"] != null) 
             {
                 paymentDateIDRef_ = paymentDateNode.Attributes["id"].Value;
                 AdjustableDate ob = new AdjustableDate(paymentDateNode);
                 IDManager.SetID(paymentDateIDRef_, ob);
             }
             else if (paymentDateNode.Attributes["href"] != null)
             {
                 paymentDateIDRef_ = paymentDateNode.Attributes["href"].Value;
             }
             else
             {
                 paymentDate_ = new AdjustableDate(paymentDateNode);
             }
         }
         else
         {
             paymentDate_ = new AdjustableDate(paymentDateNode);
         }
     }
     
 
     XmlNode fixingDateOffsetNode = xmlNode.SelectSingleNode("fixingDateOffset");
     
     if (fixingDateOffsetNode != null)
     {
         if (fixingDateOffsetNode.Attributes["href"] != null || fixingDateOffsetNode.Attributes["id"] != null) 
         {
             if (fixingDateOffsetNode.Attributes["id"] != null) 
             {
                 fixingDateOffsetIDRef_ = fixingDateOffsetNode.Attributes["id"].Value;
                 RelativeDateOffset ob = new RelativeDateOffset(fixingDateOffsetNode);
                 IDManager.SetID(fixingDateOffsetIDRef_, ob);
             }
             else if (fixingDateOffsetNode.Attributes["href"] != null)
             {
                 fixingDateOffsetIDRef_ = fixingDateOffsetNode.Attributes["href"].Value;
             }
             else
             {
                 fixingDateOffset_ = new RelativeDateOffset(fixingDateOffsetNode);
             }
         }
         else
         {
             fixingDateOffset_ = new RelativeDateOffset(fixingDateOffsetNode);
         }
     }
     
 
     XmlNode dayCountFractionNode = xmlNode.SelectSingleNode("dayCountFraction");
     
     if (dayCountFractionNode != null)
     {
         if (dayCountFractionNode.Attributes["href"] != null || dayCountFractionNode.Attributes["id"] != null) 
         {
             if (dayCountFractionNode.Attributes["id"] != null) 
             {
                 dayCountFractionIDRef_ = dayCountFractionNode.Attributes["id"].Value;
                 DayCountFraction ob = new DayCountFraction(dayCountFractionNode);
                 IDManager.SetID(dayCountFractionIDRef_, ob);
             }
             else if (dayCountFractionNode.Attributes["href"] != null)
             {
                 dayCountFractionIDRef_ = dayCountFractionNode.Attributes["href"].Value;
             }
             else
             {
                 dayCountFraction_ = new DayCountFraction(dayCountFractionNode);
             }
         }
         else
         {
             dayCountFraction_ = new DayCountFraction(dayCountFractionNode);
         }
     }
     
 
     XmlNode calculationPeriodNumberOfDaysNode = xmlNode.SelectSingleNode("calculationPeriodNumberOfDays");
     
     if (calculationPeriodNumberOfDaysNode != null)
     {
         if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null || calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
         {
             if (calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef_, ob);
             }
             else if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null)
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
             }
         }
         else
         {
             calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
         }
     }
     
 
     XmlNode notionalNode = xmlNode.SelectSingleNode("notional");
     
     if (notionalNode != null)
     {
         if (notionalNode.Attributes["href"] != null || notionalNode.Attributes["id"] != null) 
         {
             if (notionalNode.Attributes["id"] != null) 
             {
                 notionalIDRef_ = notionalNode.Attributes["id"].Value;
                 Money ob = new Money(notionalNode);
                 IDManager.SetID(notionalIDRef_, ob);
             }
             else if (notionalNode.Attributes["href"] != null)
             {
                 notionalIDRef_ = notionalNode.Attributes["href"].Value;
             }
             else
             {
                 notional_ = new Money(notionalNode);
             }
         }
         else
         {
             notional_ = new Money(notionalNode);
         }
     }
     
 
     XmlNode fixedRateNode = xmlNode.SelectSingleNode("fixedRate");
     
     if (fixedRateNode != null)
     {
         if (fixedRateNode.Attributes["href"] != null || fixedRateNode.Attributes["id"] != null) 
         {
             if (fixedRateNode.Attributes["id"] != null) 
             {
                 fixedRateIDRef_ = fixedRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(fixedRateNode);
                 IDManager.SetID(fixedRateIDRef_, ob);
             }
             else if (fixedRateNode.Attributes["href"] != null)
             {
                 fixedRateIDRef_ = fixedRateNode.Attributes["href"].Value;
             }
             else
             {
                 fixedRate_ = new XsdTypeDecimal(fixedRateNode);
             }
         }
         else
         {
             fixedRate_ = new XsdTypeDecimal(fixedRateNode);
         }
     }
     
 
     XmlNode floatingRateIndexNode = xmlNode.SelectSingleNode("floatingRateIndex");
     
     if (floatingRateIndexNode != null)
     {
         if (floatingRateIndexNode.Attributes["href"] != null || floatingRateIndexNode.Attributes["id"] != null) 
         {
             if (floatingRateIndexNode.Attributes["id"] != null) 
             {
                 floatingRateIndexIDRef_ = floatingRateIndexNode.Attributes["id"].Value;
                 FloatingRateIndex ob = new FloatingRateIndex(floatingRateIndexNode);
                 IDManager.SetID(floatingRateIndexIDRef_, ob);
             }
             else if (floatingRateIndexNode.Attributes["href"] != null)
             {
                 floatingRateIndexIDRef_ = floatingRateIndexNode.Attributes["href"].Value;
             }
             else
             {
                 floatingRateIndex_ = new FloatingRateIndex(floatingRateIndexNode);
             }
         }
         else
         {
             floatingRateIndex_ = new FloatingRateIndex(floatingRateIndexNode);
         }
     }
     
 
     XmlNodeList indexTenorNodeList = xmlNode.SelectNodes("indexTenor");
     
     if (indexTenorNodeList != null)
     {
         this.indexTenor_ = new List<Period>();
         foreach (XmlNode item in indexTenorNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     indexTenorIDRef_ = item.Attributes["id"].Value;
                     indexTenor_.Add(new Period(item));
                     IDManager.SetID(indexTenorIDRef_, indexTenor_[indexTenor_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     indexTenorIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 indexTenor_.Add(new Period(item));
                 }
             }
             else
             {
                 indexTenor_.Add(new Period(item));
             }
         }
     }
     
 
     XmlNode fraDiscountingNode = xmlNode.SelectSingleNode("fraDiscounting");
     
     if (fraDiscountingNode != null)
     {
         if (fraDiscountingNode.Attributes["href"] != null || fraDiscountingNode.Attributes["id"] != null) 
         {
             if (fraDiscountingNode.Attributes["id"] != null) 
             {
                 fraDiscountingIDRef_ = fraDiscountingNode.Attributes["id"].Value;
                 FraDiscountingEnum ob = new FraDiscountingEnum(fraDiscountingNode);
                 IDManager.SetID(fraDiscountingIDRef_, ob);
             }
             else if (fraDiscountingNode.Attributes["href"] != null)
             {
                 fraDiscountingIDRef_ = fraDiscountingNode.Attributes["href"].Value;
             }
             else
             {
                 fraDiscounting_ = new FraDiscountingEnum(fraDiscountingNode);
             }
         }
         else
         {
             fraDiscounting_ = new FraDiscountingEnum(fraDiscountingNode);
         }
     }
     
 
 }
        public RateObservation(XmlNode xmlNode)
        {
            XmlNodeList resetDateNodeList = xmlNode.SelectNodes("resetDate");

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

            foreach (XmlNode item in resetDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        resetDateIDRef = item.Attributes["id"].Name;
                        XsdTypeDate ob = XsdTypeDate();
                        IDManager.SetID(resetDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        resetDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        resetDate = new XsdTypeDate(item);
                    }
                }
            }


            XmlNodeList adjustedFixingDateNodeList = xmlNode.SelectNodes("adjustedFixingDate");

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

            foreach (XmlNode item in adjustedFixingDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        adjustedFixingDateIDRef = item.Attributes["id"].Name;
                        XsdTypeDate ob = XsdTypeDate();
                        IDManager.SetID(adjustedFixingDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        adjustedFixingDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        adjustedFixingDate = new XsdTypeDate(item);
                    }
                }
            }


            XmlNodeList observedRateNodeList = xmlNode.SelectNodes("observedRate");

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

            foreach (XmlNode item in observedRateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        observedRateIDRef = item.Attributes["id"].Name;
                        XsdTypeDecimal ob = XsdTypeDecimal();
                        IDManager.SetID(observedRateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        observedRateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        observedRate = new XsdTypeDecimal(item);
                    }
                }
            }


            XmlNodeList treatedRateNodeList = xmlNode.SelectNodes("treatedRate");

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

            foreach (XmlNode item in treatedRateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        treatedRateIDRef = item.Attributes["id"].Name;
                        XsdTypeDecimal ob = XsdTypeDecimal();
                        IDManager.SetID(treatedRateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        treatedRateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        treatedRate = new XsdTypeDecimal(item);
                    }
                }
            }


            XmlNodeList observationWeightNodeList = xmlNode.SelectNodes("observationWeight");

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

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


            XmlNodeList rateReferenceNodeList = xmlNode.SelectNodes("rateReference");

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

            foreach (XmlNode item in rateReferenceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        rateReferenceIDRef = item.Attributes["id"].Name;
                        RateReference ob = RateReference();
                        IDManager.SetID(rateReferenceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        rateReferenceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        rateReference = new RateReference(item);
                    }
                }
            }


            XmlNodeList forecastRateNodeList = xmlNode.SelectNodes("forecastRate");

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

            foreach (XmlNode item in forecastRateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        forecastRateIDRef = item.Attributes["id"].Name;
                        XsdTypeDecimal ob = XsdTypeDecimal();
                        IDManager.SetID(forecastRateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        forecastRateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        forecastRate = new XsdTypeDecimal(item);
                    }
                }
            }


            XmlNodeList treatedForecastRateNodeList = xmlNode.SelectNodes("treatedForecastRate");

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

            foreach (XmlNode item in treatedForecastRateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        treatedForecastRateIDRef = item.Attributes["id"].Name;
                        XsdTypeDecimal ob = XsdTypeDecimal();
                        IDManager.SetID(treatedForecastRateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        treatedForecastRateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        treatedForecastRate = new XsdTypeDecimal(item);
                    }
                }
            }
        }
 public NonCorrectableRequestMessage(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode parentCorrelationIdNode = xmlNode.SelectSingleNode("parentCorrelationId");
     
     if (parentCorrelationIdNode != null)
     {
         if (parentCorrelationIdNode.Attributes["href"] != null || parentCorrelationIdNode.Attributes["id"] != null) 
         {
             if (parentCorrelationIdNode.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(parentCorrelationIdNode);
                 IDManager.SetID(parentCorrelationIdIDRef_, ob);
             }
             else if (parentCorrelationIdNode.Attributes["href"] != null)
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["href"].Value;
             }
             else
             {
                 parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
             }
         }
         else
         {
             parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
         }
     }
     
 
     XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");
     
     if (correlationIdNode != null)
     {
         if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null) 
         {
             if (correlationIdNode.Attributes["id"] != null) 
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(correlationIdNode);
                 IDManager.SetID(correlationIdIDRef_, ob);
             }
             else if (correlationIdNode.Attributes["href"] != null)
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
             }
             else
             {
                 correlationId_ = new CorrelationId(correlationIdNode);
             }
         }
         else
         {
             correlationId_ = new CorrelationId(correlationIdNode);
         }
     }
     
 
     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 onBehalfOfNode = xmlNode.SelectSingleNode("onBehalfOf");
     
     if (onBehalfOfNode != null)
     {
         if (onBehalfOfNode.Attributes["href"] != null || onBehalfOfNode.Attributes["id"] != null) 
         {
             if (onBehalfOfNode.Attributes["id"] != null) 
             {
                 onBehalfOfIDRef_ = onBehalfOfNode.Attributes["id"].Value;
                 OnBehalfOf ob = new OnBehalfOf(onBehalfOfNode);
                 IDManager.SetID(onBehalfOfIDRef_, ob);
             }
             else if (onBehalfOfNode.Attributes["href"] != null)
             {
                 onBehalfOfIDRef_ = onBehalfOfNode.Attributes["href"].Value;
             }
             else
             {
                 onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
             }
         }
         else
         {
             onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
         }
     }
     
 
 }
        public Correlation(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode notionalAmountNode = xmlNode.SelectSingleNode("notionalAmount");

            if (notionalAmountNode != null)
            {
                if (notionalAmountNode.Attributes["href"] != null || notionalAmountNode.Attributes["id"] != null)
                {
                    if (notionalAmountNode.Attributes["id"] != null)
                    {
                        notionalAmountIDRef_ = notionalAmountNode.Attributes["id"].Value;
                        NonNegativeMoney ob = new NonNegativeMoney(notionalAmountNode);
                        IDManager.SetID(notionalAmountIDRef_, ob);
                    }
                    else if (notionalAmountNode.Attributes["href"] != null)
                    {
                        notionalAmountIDRef_ = notionalAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        notionalAmount_ = new NonNegativeMoney(notionalAmountNode);
                    }
                }
                else
                {
                    notionalAmount_ = new NonNegativeMoney(notionalAmountNode);
                }
            }


            XmlNode correlationStrikePriceNode = xmlNode.SelectSingleNode("correlationStrikePrice");

            if (correlationStrikePriceNode != null)
            {
                if (correlationStrikePriceNode.Attributes["href"] != null || correlationStrikePriceNode.Attributes["id"] != null)
                {
                    if (correlationStrikePriceNode.Attributes["id"] != null)
                    {
                        correlationStrikePriceIDRef_ = correlationStrikePriceNode.Attributes["id"].Value;
                        CorrelationValue ob = new CorrelationValue(correlationStrikePriceNode);
                        IDManager.SetID(correlationStrikePriceIDRef_, ob);
                    }
                    else if (correlationStrikePriceNode.Attributes["href"] != null)
                    {
                        correlationStrikePriceIDRef_ = correlationStrikePriceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        correlationStrikePrice_ = new CorrelationValue(correlationStrikePriceNode);
                    }
                }
                else
                {
                    correlationStrikePrice_ = new CorrelationValue(correlationStrikePriceNode);
                }
            }


            XmlNode boundedCorrelationNode = xmlNode.SelectSingleNode("boundedCorrelation");

            if (boundedCorrelationNode != null)
            {
                if (boundedCorrelationNode.Attributes["href"] != null || boundedCorrelationNode.Attributes["id"] != null)
                {
                    if (boundedCorrelationNode.Attributes["id"] != null)
                    {
                        boundedCorrelationIDRef_ = boundedCorrelationNode.Attributes["id"].Value;
                        BoundedCorrelation ob = new BoundedCorrelation(boundedCorrelationNode);
                        IDManager.SetID(boundedCorrelationIDRef_, ob);
                    }
                    else if (boundedCorrelationNode.Attributes["href"] != null)
                    {
                        boundedCorrelationIDRef_ = boundedCorrelationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        boundedCorrelation_ = new BoundedCorrelation(boundedCorrelationNode);
                    }
                }
                else
                {
                    boundedCorrelation_ = new BoundedCorrelation(boundedCorrelationNode);
                }
            }


            XmlNode numberOfDataSeriesNode = xmlNode.SelectSingleNode("numberOfDataSeries");

            if (numberOfDataSeriesNode != null)
            {
                if (numberOfDataSeriesNode.Attributes["href"] != null || numberOfDataSeriesNode.Attributes["id"] != null)
                {
                    if (numberOfDataSeriesNode.Attributes["id"] != null)
                    {
                        numberOfDataSeriesIDRef_ = numberOfDataSeriesNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(numberOfDataSeriesNode);
                        IDManager.SetID(numberOfDataSeriesIDRef_, ob);
                    }
                    else if (numberOfDataSeriesNode.Attributes["href"] != null)
                    {
                        numberOfDataSeriesIDRef_ = numberOfDataSeriesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        numberOfDataSeries_ = new XsdTypePositiveInteger(numberOfDataSeriesNode);
                    }
                }
                else
                {
                    numberOfDataSeries_ = new XsdTypePositiveInteger(numberOfDataSeriesNode);
                }
            }
        }
Beispiel #50
0
        public Exception(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode headerNode = xmlNode.SelectSingleNode("header");

            if (headerNode != null)
            {
                if (headerNode.Attributes["href"] != null || headerNode.Attributes["id"] != null)
                {
                    if (headerNode.Attributes["id"] != null)
                    {
                        headerIDRef_ = headerNode.Attributes["id"].Value;
                        ExceptionMessageHeader ob = new ExceptionMessageHeader(headerNode);
                        IDManager.SetID(headerIDRef_, ob);
                    }
                    else if (headerNode.Attributes["href"] != null)
                    {
                        headerIDRef_ = headerNode.Attributes["href"].Value;
                    }
                    else
                    {
                        header_ = new ExceptionMessageHeader(headerNode);
                    }
                }
                else
                {
                    header_ = new ExceptionMessageHeader(headerNode);
                }
            }


            XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");

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


            XmlNode parentCorrelationIdNode = xmlNode.SelectSingleNode("parentCorrelationId");

            if (parentCorrelationIdNode != null)
            {
                if (parentCorrelationIdNode.Attributes["href"] != null || parentCorrelationIdNode.Attributes["id"] != null)
                {
                    if (parentCorrelationIdNode.Attributes["id"] != null)
                    {
                        parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["id"].Value;
                        CorrelationId ob = new CorrelationId(parentCorrelationIdNode);
                        IDManager.SetID(parentCorrelationIdIDRef_, ob);
                    }
                    else if (parentCorrelationIdNode.Attributes["href"] != null)
                    {
                        parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
                    }
                }
                else
                {
                    parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
                }
            }


            XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");

            if (correlationIdNode != null)
            {
                if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null)
                {
                    if (correlationIdNode.Attributes["id"] != null)
                    {
                        correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                        CorrelationId ob = new CorrelationId(correlationIdNode);
                        IDManager.SetID(correlationIdIDRef_, ob);
                    }
                    else if (correlationIdNode.Attributes["href"] != null)
                    {
                        correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        correlationId_ = new CorrelationId(correlationIdNode);
                    }
                }
                else
                {
                    correlationId_ = new CorrelationId(correlationIdNode);
                }
            }


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


            XmlNodeList reasonNodeList = xmlNode.SelectNodes("reason");

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


            XmlNode additionalDataNode = xmlNode.SelectSingleNode("additionalData");

            if (additionalDataNode != null)
            {
                if (additionalDataNode.Attributes["href"] != null || additionalDataNode.Attributes["id"] != null)
                {
                    if (additionalDataNode.Attributes["id"] != null)
                    {
                        additionalDataIDRef_ = additionalDataNode.Attributes["id"].Value;
                        AdditionalData ob = new AdditionalData(additionalDataNode);
                        IDManager.SetID(additionalDataIDRef_, ob);
                    }
                    else if (additionalDataNode.Attributes["href"] != null)
                    {
                        additionalDataIDRef_ = additionalDataNode.Attributes["href"].Value;
                    }
                    else
                    {
                        additionalData_ = new AdditionalData(additionalDataNode);
                    }
                }
                else
                {
                    additionalData_ = new AdditionalData(additionalDataNode);
                }
            }
        }
        public IntermediaryInformation(XmlNode xmlNode)
        {
            XmlNode routingIdsNode = xmlNode.SelectSingleNode("routingIds");

            if (routingIdsNode != null)
            {
                if (routingIdsNode.Attributes["href"] != null || routingIdsNode.Attributes["id"] != null)
                {
                    if (routingIdsNode.Attributes["id"] != null)
                    {
                        routingIdsIDRef_ = routingIdsNode.Attributes["id"].Value;
                        RoutingIds ob = new RoutingIds(routingIdsNode);
                        IDManager.SetID(routingIdsIDRef_, ob);
                    }
                    else if (routingIdsNode.Attributes["href"] != null)
                    {
                        routingIdsIDRef_ = routingIdsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        routingIds_ = new RoutingIds(routingIdsNode);
                    }
                }
                else
                {
                    routingIds_ = new RoutingIds(routingIdsNode);
                }
            }


            XmlNode routingExplicitDetailsNode = xmlNode.SelectSingleNode("routingExplicitDetails");

            if (routingExplicitDetailsNode != null)
            {
                if (routingExplicitDetailsNode.Attributes["href"] != null || routingExplicitDetailsNode.Attributes["id"] != null)
                {
                    if (routingExplicitDetailsNode.Attributes["id"] != null)
                    {
                        routingExplicitDetailsIDRef_ = routingExplicitDetailsNode.Attributes["id"].Value;
                        RoutingExplicitDetails ob = new RoutingExplicitDetails(routingExplicitDetailsNode);
                        IDManager.SetID(routingExplicitDetailsIDRef_, ob);
                    }
                    else if (routingExplicitDetailsNode.Attributes["href"] != null)
                    {
                        routingExplicitDetailsIDRef_ = routingExplicitDetailsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        routingExplicitDetails_ = new RoutingExplicitDetails(routingExplicitDetailsNode);
                    }
                }
                else
                {
                    routingExplicitDetails_ = new RoutingExplicitDetails(routingExplicitDetailsNode);
                }
            }


            XmlNode routingIdsAndExplicitDetailsNode = xmlNode.SelectSingleNode("routingIdsAndExplicitDetails");

            if (routingIdsAndExplicitDetailsNode != null)
            {
                if (routingIdsAndExplicitDetailsNode.Attributes["href"] != null || routingIdsAndExplicitDetailsNode.Attributes["id"] != null)
                {
                    if (routingIdsAndExplicitDetailsNode.Attributes["id"] != null)
                    {
                        routingIdsAndExplicitDetailsIDRef_ = routingIdsAndExplicitDetailsNode.Attributes["id"].Value;
                        RoutingIdsAndExplicitDetails ob = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
                        IDManager.SetID(routingIdsAndExplicitDetailsIDRef_, ob);
                    }
                    else if (routingIdsAndExplicitDetailsNode.Attributes["href"] != null)
                    {
                        routingIdsAndExplicitDetailsIDRef_ = routingIdsAndExplicitDetailsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        routingIdsAndExplicitDetails_ = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
                    }
                }
                else
                {
                    routingIdsAndExplicitDetails_ = new RoutingIdsAndExplicitDetails(routingIdsAndExplicitDetailsNode);
                }
            }


            XmlNode intermediarySequenceNumberNode = xmlNode.SelectSingleNode("intermediarySequenceNumber");

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


            XmlNode intermediaryPartyReferenceNode = xmlNode.SelectSingleNode("intermediaryPartyReference");

            if (intermediaryPartyReferenceNode != null)
            {
                if (intermediaryPartyReferenceNode.Attributes["href"] != null || intermediaryPartyReferenceNode.Attributes["id"] != null)
                {
                    if (intermediaryPartyReferenceNode.Attributes["id"] != null)
                    {
                        intermediaryPartyReferenceIDRef_ = intermediaryPartyReferenceNode.Attributes["id"].Value;
                        PartyReference ob = new PartyReference(intermediaryPartyReferenceNode);
                        IDManager.SetID(intermediaryPartyReferenceIDRef_, ob);
                    }
                    else if (intermediaryPartyReferenceNode.Attributes["href"] != null)
                    {
                        intermediaryPartyReferenceIDRef_ = intermediaryPartyReferenceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        intermediaryPartyReference_ = new PartyReference(intermediaryPartyReferenceNode);
                    }
                }
                else
                {
                    intermediaryPartyReference_ = new PartyReference(intermediaryPartyReferenceNode);
                }
            }
        }
        public WeightedAveragingObservation(XmlNode xmlNode)
        {
            XmlNode dateTimeNode = xmlNode.SelectSingleNode("dateTime");

            if (dateTimeNode != null)
            {
                if (dateTimeNode.Attributes["href"] != null || dateTimeNode.Attributes["id"] != null)
                {
                    if (dateTimeNode.Attributes["id"] != null)
                    {
                        dateTimeIDRef_ = dateTimeNode.Attributes["id"].Value;
                        XsdTypeDateTime ob = new XsdTypeDateTime(dateTimeNode);
                        IDManager.SetID(dateTimeIDRef_, ob);
                    }
                    else if (dateTimeNode.Attributes["href"] != null)
                    {
                        dateTimeIDRef_ = dateTimeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        dateTime_ = new XsdTypeDateTime(dateTimeNode);
                    }
                }
                else
                {
                    dateTime_ = new XsdTypeDateTime(dateTimeNode);
                }
            }


            XmlNode observationNumberNode = xmlNode.SelectSingleNode("observationNumber");

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


            XmlNode weightNode = xmlNode.SelectSingleNode("weight");

            if (weightNode != null)
            {
                if (weightNode.Attributes["href"] != null || weightNode.Attributes["id"] != null)
                {
                    if (weightNode.Attributes["id"] != null)
                    {
                        weightIDRef_ = weightNode.Attributes["id"].Value;
                        NonNegativeDecimal ob = new NonNegativeDecimal(weightNode);
                        IDManager.SetID(weightIDRef_, ob);
                    }
                    else if (weightNode.Attributes["href"] != null)
                    {
                        weightIDRef_ = weightNode.Attributes["href"].Value;
                    }
                    else
                    {
                        weight_ = new NonNegativeDecimal(weightNode);
                    }
                }
                else
                {
                    weight_ = new NonNegativeDecimal(weightNode);
                }
            }
        }
        public CorrectableRequestMessage(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode isCorrectionNode = xmlNode.SelectSingleNode("isCorrection");

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


            XmlNode parentCorrelationIdNode = xmlNode.SelectSingleNode("parentCorrelationId");

            if (parentCorrelationIdNode != null)
            {
                if (parentCorrelationIdNode.Attributes["href"] != null || parentCorrelationIdNode.Attributes["id"] != null)
                {
                    if (parentCorrelationIdNode.Attributes["id"] != null)
                    {
                        parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["id"].Value;
                        CorrelationId ob = new CorrelationId(parentCorrelationIdNode);
                        IDManager.SetID(parentCorrelationIdIDRef_, ob);
                    }
                    else if (parentCorrelationIdNode.Attributes["href"] != null)
                    {
                        parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
                    }
                }
                else
                {
                    parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
                }
            }


            XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");

            if (correlationIdNode != null)
            {
                if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null)
                {
                    if (correlationIdNode.Attributes["id"] != null)
                    {
                        correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                        CorrelationId ob = new CorrelationId(correlationIdNode);
                        IDManager.SetID(correlationIdIDRef_, ob);
                    }
                    else if (correlationIdNode.Attributes["href"] != null)
                    {
                        correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        correlationId_ = new CorrelationId(correlationIdNode);
                    }
                }
                else
                {
                    correlationId_ = new CorrelationId(correlationIdNode);
                }
            }


            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 onBehalfOfNode = xmlNode.SelectSingleNode("onBehalfOf");

            if (onBehalfOfNode != null)
            {
                if (onBehalfOfNode.Attributes["href"] != null || onBehalfOfNode.Attributes["id"] != null)
                {
                    if (onBehalfOfNode.Attributes["id"] != null)
                    {
                        onBehalfOfIDRef_ = onBehalfOfNode.Attributes["id"].Value;
                        OnBehalfOf ob = new OnBehalfOf(onBehalfOfNode);
                        IDManager.SetID(onBehalfOfIDRef_, ob);
                    }
                    else if (onBehalfOfNode.Attributes["href"] != null)
                    {
                        onBehalfOfIDRef_ = onBehalfOfNode.Attributes["href"].Value;
                    }
                    else
                    {
                        onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
                    }
                }
                else
                {
                    onBehalfOf_ = new OnBehalfOf(onBehalfOfNode);
                }
            }
        }
 public WeightedAveragingObservation(XmlNode xmlNode)
 {
     XmlNode dateTimeNode = xmlNode.SelectSingleNode("dateTime");
     
     if (dateTimeNode != null)
     {
         if (dateTimeNode.Attributes["href"] != null || dateTimeNode.Attributes["id"] != null) 
         {
             if (dateTimeNode.Attributes["id"] != null) 
             {
                 dateTimeIDRef_ = dateTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(dateTimeNode);
                 IDManager.SetID(dateTimeIDRef_, ob);
             }
             else if (dateTimeNode.Attributes["href"] != null)
             {
                 dateTimeIDRef_ = dateTimeNode.Attributes["href"].Value;
             }
             else
             {
                 dateTime_ = new XsdTypeDateTime(dateTimeNode);
             }
         }
         else
         {
             dateTime_ = new XsdTypeDateTime(dateTimeNode);
         }
     }
     
 
     XmlNode observationNumberNode = xmlNode.SelectSingleNode("observationNumber");
     
     if (observationNumberNode != null)
     {
         if (observationNumberNode.Attributes["href"] != null || observationNumberNode.Attributes["id"] != null) 
         {
             if (observationNumberNode.Attributes["id"] != null) 
             {
                 observationNumberIDRef_ = observationNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(observationNumberNode);
                 IDManager.SetID(observationNumberIDRef_, ob);
             }
             else if (observationNumberNode.Attributes["href"] != null)
             {
                 observationNumberIDRef_ = observationNumberNode.Attributes["href"].Value;
             }
             else
             {
                 observationNumber_ = new XsdTypePositiveInteger(observationNumberNode);
             }
         }
         else
         {
             observationNumber_ = new XsdTypePositiveInteger(observationNumberNode);
         }
     }
     
 
     XmlNode weightNode = xmlNode.SelectSingleNode("weight");
     
     if (weightNode != null)
     {
         if (weightNode.Attributes["href"] != null || weightNode.Attributes["id"] != null) 
         {
             if (weightNode.Attributes["id"] != null) 
             {
                 weightIDRef_ = weightNode.Attributes["id"].Value;
                 NonNegativeDecimal ob = new NonNegativeDecimal(weightNode);
                 IDManager.SetID(weightIDRef_, ob);
             }
             else if (weightNode.Attributes["href"] != null)
             {
                 weightIDRef_ = weightNode.Attributes["href"].Value;
             }
             else
             {
                 weight_ = new NonNegativeDecimal(weightNode);
             }
         }
         else
         {
             weight_ = new NonNegativeDecimal(weightNode);
         }
     }
     
 
 }
 public CalculationPeriod(XmlNode xmlNode)
 {
     XmlNode unadjustedStartDateNode = xmlNode.SelectSingleNode("unadjustedStartDate");
     
     if (unadjustedStartDateNode != null)
     {
         if (unadjustedStartDateNode.Attributes["href"] != null || unadjustedStartDateNode.Attributes["id"] != null) 
         {
             if (unadjustedStartDateNode.Attributes["id"] != null) 
             {
                 unadjustedStartDateIDRef_ = unadjustedStartDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(unadjustedStartDateNode);
                 IDManager.SetID(unadjustedStartDateIDRef_, ob);
             }
             else if (unadjustedStartDateNode.Attributes["href"] != null)
             {
                 unadjustedStartDateIDRef_ = unadjustedStartDateNode.Attributes["href"].Value;
             }
             else
             {
                 unadjustedStartDate_ = new XsdTypeDate(unadjustedStartDateNode);
             }
         }
         else
         {
             unadjustedStartDate_ = new XsdTypeDate(unadjustedStartDateNode);
         }
     }
     
 
     XmlNode unadjustedEndDateNode = xmlNode.SelectSingleNode("unadjustedEndDate");
     
     if (unadjustedEndDateNode != null)
     {
         if (unadjustedEndDateNode.Attributes["href"] != null || unadjustedEndDateNode.Attributes["id"] != null) 
         {
             if (unadjustedEndDateNode.Attributes["id"] != null) 
             {
                 unadjustedEndDateIDRef_ = unadjustedEndDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(unadjustedEndDateNode);
                 IDManager.SetID(unadjustedEndDateIDRef_, ob);
             }
             else if (unadjustedEndDateNode.Attributes["href"] != null)
             {
                 unadjustedEndDateIDRef_ = unadjustedEndDateNode.Attributes["href"].Value;
             }
             else
             {
                 unadjustedEndDate_ = new XsdTypeDate(unadjustedEndDateNode);
             }
         }
         else
         {
             unadjustedEndDate_ = new XsdTypeDate(unadjustedEndDateNode);
         }
     }
     
 
     XmlNode adjustedStartDateNode = xmlNode.SelectSingleNode("adjustedStartDate");
     
     if (adjustedStartDateNode != null)
     {
         if (adjustedStartDateNode.Attributes["href"] != null || adjustedStartDateNode.Attributes["id"] != null) 
         {
             if (adjustedStartDateNode.Attributes["id"] != null) 
             {
                 adjustedStartDateIDRef_ = adjustedStartDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(adjustedStartDateNode);
                 IDManager.SetID(adjustedStartDateIDRef_, ob);
             }
             else if (adjustedStartDateNode.Attributes["href"] != null)
             {
                 adjustedStartDateIDRef_ = adjustedStartDateNode.Attributes["href"].Value;
             }
             else
             {
                 adjustedStartDate_ = new XsdTypeDate(adjustedStartDateNode);
             }
         }
         else
         {
             adjustedStartDate_ = new XsdTypeDate(adjustedStartDateNode);
         }
     }
     
 
     XmlNode adjustedEndDateNode = xmlNode.SelectSingleNode("adjustedEndDate");
     
     if (adjustedEndDateNode != null)
     {
         if (adjustedEndDateNode.Attributes["href"] != null || adjustedEndDateNode.Attributes["id"] != null) 
         {
             if (adjustedEndDateNode.Attributes["id"] != null) 
             {
                 adjustedEndDateIDRef_ = adjustedEndDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(adjustedEndDateNode);
                 IDManager.SetID(adjustedEndDateIDRef_, ob);
             }
             else if (adjustedEndDateNode.Attributes["href"] != null)
             {
                 adjustedEndDateIDRef_ = adjustedEndDateNode.Attributes["href"].Value;
             }
             else
             {
                 adjustedEndDate_ = new XsdTypeDate(adjustedEndDateNode);
             }
         }
         else
         {
             adjustedEndDate_ = new XsdTypeDate(adjustedEndDateNode);
         }
     }
     
 
     XmlNode calculationPeriodNumberOfDaysNode = xmlNode.SelectSingleNode("calculationPeriodNumberOfDays");
     
     if (calculationPeriodNumberOfDaysNode != null)
     {
         if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null || calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
         {
             if (calculationPeriodNumberOfDaysNode.Attributes["id"] != null) 
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
                 IDManager.SetID(calculationPeriodNumberOfDaysIDRef_, ob);
             }
             else if (calculationPeriodNumberOfDaysNode.Attributes["href"] != null)
             {
                 calculationPeriodNumberOfDaysIDRef_ = calculationPeriodNumberOfDaysNode.Attributes["href"].Value;
             }
             else
             {
                 calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
             }
         }
         else
         {
             calculationPeriodNumberOfDays_ = new XsdTypePositiveInteger(calculationPeriodNumberOfDaysNode);
         }
     }
     
 
     XmlNode notionalAmountNode = xmlNode.SelectSingleNode("notionalAmount");
     
     if (notionalAmountNode != null)
     {
         if (notionalAmountNode.Attributes["href"] != null || notionalAmountNode.Attributes["id"] != null) 
         {
             if (notionalAmountNode.Attributes["id"] != null) 
             {
                 notionalAmountIDRef_ = notionalAmountNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(notionalAmountNode);
                 IDManager.SetID(notionalAmountIDRef_, ob);
             }
             else if (notionalAmountNode.Attributes["href"] != null)
             {
                 notionalAmountIDRef_ = notionalAmountNode.Attributes["href"].Value;
             }
             else
             {
                 notionalAmount_ = new XsdTypeDecimal(notionalAmountNode);
             }
         }
         else
         {
             notionalAmount_ = new XsdTypeDecimal(notionalAmountNode);
         }
     }
     
 
     XmlNode fxLinkedNotionalAmountNode = xmlNode.SelectSingleNode("fxLinkedNotionalAmount");
     
     if (fxLinkedNotionalAmountNode != null)
     {
         if (fxLinkedNotionalAmountNode.Attributes["href"] != null || fxLinkedNotionalAmountNode.Attributes["id"] != null) 
         {
             if (fxLinkedNotionalAmountNode.Attributes["id"] != null) 
             {
                 fxLinkedNotionalAmountIDRef_ = fxLinkedNotionalAmountNode.Attributes["id"].Value;
                 FxLinkedNotionalAmount ob = new FxLinkedNotionalAmount(fxLinkedNotionalAmountNode);
                 IDManager.SetID(fxLinkedNotionalAmountIDRef_, ob);
             }
             else if (fxLinkedNotionalAmountNode.Attributes["href"] != null)
             {
                 fxLinkedNotionalAmountIDRef_ = fxLinkedNotionalAmountNode.Attributes["href"].Value;
             }
             else
             {
                 fxLinkedNotionalAmount_ = new FxLinkedNotionalAmount(fxLinkedNotionalAmountNode);
             }
         }
         else
         {
             fxLinkedNotionalAmount_ = new FxLinkedNotionalAmount(fxLinkedNotionalAmountNode);
         }
     }
     
 
     XmlNode floatingRateDefinitionNode = xmlNode.SelectSingleNode("floatingRateDefinition");
     
     if (floatingRateDefinitionNode != null)
     {
         if (floatingRateDefinitionNode.Attributes["href"] != null || floatingRateDefinitionNode.Attributes["id"] != null) 
         {
             if (floatingRateDefinitionNode.Attributes["id"] != null) 
             {
                 floatingRateDefinitionIDRef_ = floatingRateDefinitionNode.Attributes["id"].Value;
                 FloatingRateDefinition ob = new FloatingRateDefinition(floatingRateDefinitionNode);
                 IDManager.SetID(floatingRateDefinitionIDRef_, ob);
             }
             else if (floatingRateDefinitionNode.Attributes["href"] != null)
             {
                 floatingRateDefinitionIDRef_ = floatingRateDefinitionNode.Attributes["href"].Value;
             }
             else
             {
                 floatingRateDefinition_ = new FloatingRateDefinition(floatingRateDefinitionNode);
             }
         }
         else
         {
             floatingRateDefinition_ = new FloatingRateDefinition(floatingRateDefinitionNode);
         }
     }
     
 
     XmlNode fixedRateNode = xmlNode.SelectSingleNode("fixedRate");
     
     if (fixedRateNode != null)
     {
         if (fixedRateNode.Attributes["href"] != null || fixedRateNode.Attributes["id"] != null) 
         {
             if (fixedRateNode.Attributes["id"] != null) 
             {
                 fixedRateIDRef_ = fixedRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(fixedRateNode);
                 IDManager.SetID(fixedRateIDRef_, ob);
             }
             else if (fixedRateNode.Attributes["href"] != null)
             {
                 fixedRateIDRef_ = fixedRateNode.Attributes["href"].Value;
             }
             else
             {
                 fixedRate_ = new XsdTypeDecimal(fixedRateNode);
             }
         }
         else
         {
             fixedRate_ = new XsdTypeDecimal(fixedRateNode);
         }
     }
     
 
     XmlNode dayCountYearFractionNode = xmlNode.SelectSingleNode("dayCountYearFraction");
     
     if (dayCountYearFractionNode != null)
     {
         if (dayCountYearFractionNode.Attributes["href"] != null || dayCountYearFractionNode.Attributes["id"] != null) 
         {
             if (dayCountYearFractionNode.Attributes["id"] != null) 
             {
                 dayCountYearFractionIDRef_ = dayCountYearFractionNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(dayCountYearFractionNode);
                 IDManager.SetID(dayCountYearFractionIDRef_, ob);
             }
             else if (dayCountYearFractionNode.Attributes["href"] != null)
             {
                 dayCountYearFractionIDRef_ = dayCountYearFractionNode.Attributes["href"].Value;
             }
             else
             {
                 dayCountYearFraction_ = new XsdTypeDecimal(dayCountYearFractionNode);
             }
         }
         else
         {
             dayCountYearFraction_ = new XsdTypeDecimal(dayCountYearFractionNode);
         }
     }
     
 
     XmlNode forecastAmountNode = xmlNode.SelectSingleNode("forecastAmount");
     
     if (forecastAmountNode != null)
     {
         if (forecastAmountNode.Attributes["href"] != null || forecastAmountNode.Attributes["id"] != null) 
         {
             if (forecastAmountNode.Attributes["id"] != null) 
             {
                 forecastAmountIDRef_ = forecastAmountNode.Attributes["id"].Value;
                 Money ob = new Money(forecastAmountNode);
                 IDManager.SetID(forecastAmountIDRef_, ob);
             }
             else if (forecastAmountNode.Attributes["href"] != null)
             {
                 forecastAmountIDRef_ = forecastAmountNode.Attributes["href"].Value;
             }
             else
             {
                 forecastAmount_ = new Money(forecastAmountNode);
             }
         }
         else
         {
             forecastAmount_ = new Money(forecastAmountNode);
         }
     }
     
 
     XmlNode forecastRateNode = xmlNode.SelectSingleNode("forecastRate");
     
     if (forecastRateNode != null)
     {
         if (forecastRateNode.Attributes["href"] != null || forecastRateNode.Attributes["id"] != null) 
         {
             if (forecastRateNode.Attributes["id"] != null) 
             {
                 forecastRateIDRef_ = forecastRateNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(forecastRateNode);
                 IDManager.SetID(forecastRateIDRef_, ob);
             }
             else if (forecastRateNode.Attributes["href"] != null)
             {
                 forecastRateIDRef_ = forecastRateNode.Attributes["href"].Value;
             }
             else
             {
                 forecastRate_ = new XsdTypeDecimal(forecastRateNode);
             }
         }
         else
         {
             forecastRate_ = new XsdTypeDecimal(forecastRateNode);
         }
     }
     
 
 }
 public Future(XmlNode xmlNode)
 : base(xmlNode)
 {
     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;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(multiplierNode);
                 IDManager.SetID(multiplierIDRef_, ob);
             }
             else if (multiplierNode.Attributes["href"] != null)
             {
                 multiplierIDRef_ = multiplierNode.Attributes["href"].Value;
             }
             else
             {
                 multiplier_ = new XsdTypePositiveInteger(multiplierNode);
             }
         }
         else
         {
             multiplier_ = new XsdTypePositiveInteger(multiplierNode);
         }
     }
     
 
     XmlNode futureContractReferenceNode = xmlNode.SelectSingleNode("futureContractReference");
     
     if (futureContractReferenceNode != null)
     {
         if (futureContractReferenceNode.Attributes["href"] != null || futureContractReferenceNode.Attributes["id"] != null) 
         {
             if (futureContractReferenceNode.Attributes["id"] != null) 
             {
                 futureContractReferenceIDRef_ = futureContractReferenceNode.Attributes["id"].Value;
                 XsdTypeString ob = new XsdTypeString(futureContractReferenceNode);
                 IDManager.SetID(futureContractReferenceIDRef_, ob);
             }
             else if (futureContractReferenceNode.Attributes["href"] != null)
             {
                 futureContractReferenceIDRef_ = futureContractReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 futureContractReference_ = new XsdTypeString(futureContractReferenceNode);
             }
         }
         else
         {
             futureContractReference_ = new XsdTypeString(futureContractReferenceNode);
         }
     }
     
 
     XmlNode maturityNode = xmlNode.SelectSingleNode("maturity");
     
     if (maturityNode != null)
     {
         if (maturityNode.Attributes["href"] != null || maturityNode.Attributes["id"] != null) 
         {
             if (maturityNode.Attributes["id"] != null) 
             {
                 maturityIDRef_ = maturityNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(maturityNode);
                 IDManager.SetID(maturityIDRef_, ob);
             }
             else if (maturityNode.Attributes["href"] != null)
             {
                 maturityIDRef_ = maturityNode.Attributes["href"].Value;
             }
             else
             {
                 maturity_ = new XsdTypeDate(maturityNode);
             }
         }
         else
         {
             maturity_ = new XsdTypeDate(maturityNode);
         }
     }
     
 
 }
 public EventIdentifier(XmlNode xmlNode)
 {
     XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");
     
     if (correlationIdNode != null)
     {
         if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null) 
         {
             if (correlationIdNode.Attributes["id"] != null) 
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(correlationIdNode);
                 IDManager.SetID(correlationIdIDRef_, ob);
             }
             else if (correlationIdNode.Attributes["href"] != null)
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
             }
             else
             {
                 correlationId_ = new CorrelationId(correlationIdNode);
             }
         }
         else
         {
             correlationId_ = new CorrelationId(correlationIdNode);
         }
     }
     
 
     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 tradeIdentifierNode = xmlNode.SelectSingleNode("tradeIdentifier");
     
     if (tradeIdentifierNode != null)
     {
         if (tradeIdentifierNode.Attributes["href"] != null || tradeIdentifierNode.Attributes["id"] != null) 
         {
             if (tradeIdentifierNode.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(tradeIdentifierNode);
                 IDManager.SetID(tradeIdentifierIDRef_, ob);
             }
             else if (tradeIdentifierNode.Attributes["href"] != null)
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["href"].Value;
             }
             else
             {
                 tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
             }
         }
         else
         {
             tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
         }
     }
     
 
 }
 public Exception(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode headerNode = xmlNode.SelectSingleNode("header");
     
     if (headerNode != null)
     {
         if (headerNode.Attributes["href"] != null || headerNode.Attributes["id"] != null) 
         {
             if (headerNode.Attributes["id"] != null) 
             {
                 headerIDRef_ = headerNode.Attributes["id"].Value;
                 ExceptionMessageHeader ob = new ExceptionMessageHeader(headerNode);
                 IDManager.SetID(headerIDRef_, ob);
             }
             else if (headerNode.Attributes["href"] != null)
             {
                 headerIDRef_ = headerNode.Attributes["href"].Value;
             }
             else
             {
                 header_ = new ExceptionMessageHeader(headerNode);
             }
         }
         else
         {
             header_ = new ExceptionMessageHeader(headerNode);
         }
     }
     
 
     XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");
     
     if (validationNodeList != null)
     {
         this.validation_ = new List<Validation>();
         foreach (XmlNode item in validationNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     validationIDRef_ = item.Attributes["id"].Value;
                     validation_.Add(new Validation(item));
                     IDManager.SetID(validationIDRef_, validation_[validation_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     validationIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 validation_.Add(new Validation(item));
                 }
             }
             else
             {
                 validation_.Add(new Validation(item));
             }
         }
     }
     
 
     XmlNode parentCorrelationIdNode = xmlNode.SelectSingleNode("parentCorrelationId");
     
     if (parentCorrelationIdNode != null)
     {
         if (parentCorrelationIdNode.Attributes["href"] != null || parentCorrelationIdNode.Attributes["id"] != null) 
         {
             if (parentCorrelationIdNode.Attributes["id"] != null) 
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(parentCorrelationIdNode);
                 IDManager.SetID(parentCorrelationIdIDRef_, ob);
             }
             else if (parentCorrelationIdNode.Attributes["href"] != null)
             {
                 parentCorrelationIdIDRef_ = parentCorrelationIdNode.Attributes["href"].Value;
             }
             else
             {
                 parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
             }
         }
         else
         {
             parentCorrelationId_ = new CorrelationId(parentCorrelationIdNode);
         }
     }
     
 
     XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");
     
     if (correlationIdNode != null)
     {
         if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null) 
         {
             if (correlationIdNode.Attributes["id"] != null) 
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(correlationIdNode);
                 IDManager.SetID(correlationIdIDRef_, ob);
             }
             else if (correlationIdNode.Attributes["href"] != null)
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
             }
             else
             {
                 correlationId_ = new CorrelationId(correlationIdNode);
             }
         }
         else
         {
             correlationId_ = new CorrelationId(correlationIdNode);
         }
     }
     
 
     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);
         }
     }
     
 
     XmlNodeList reasonNodeList = xmlNode.SelectNodes("reason");
     
     if (reasonNodeList != null)
     {
         this.reason_ = new List<Reason>();
         foreach (XmlNode item in reasonNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     reasonIDRef_ = item.Attributes["id"].Value;
                     reason_.Add(new Reason(item));
                     IDManager.SetID(reasonIDRef_, reason_[reason_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     reasonIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 reason_.Add(new Reason(item));
                 }
             }
             else
             {
                 reason_.Add(new Reason(item));
             }
         }
     }
     
 
     XmlNode additionalDataNode = xmlNode.SelectSingleNode("additionalData");
     
     if (additionalDataNode != null)
     {
         if (additionalDataNode.Attributes["href"] != null || additionalDataNode.Attributes["id"] != null) 
         {
             if (additionalDataNode.Attributes["id"] != null) 
             {
                 additionalDataIDRef_ = additionalDataNode.Attributes["id"].Value;
                 AdditionalData ob = new AdditionalData(additionalDataNode);
                 IDManager.SetID(additionalDataIDRef_, ob);
             }
             else if (additionalDataNode.Attributes["href"] != null)
             {
                 additionalDataIDRef_ = additionalDataNode.Attributes["href"].Value;
             }
             else
             {
                 additionalData_ = new AdditionalData(additionalDataNode);
             }
         }
         else
         {
             additionalData_ = new AdditionalData(additionalDataNode);
         }
     }
     
 
 }
        public ResponseMessage(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList headerNodeList = xmlNode.SelectNodes("header");

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

            foreach (XmlNode item in headerNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        headerIDRef = item.Attributes["id"].Name;
                        ResponseMessageHeader ob = ResponseMessageHeader();
                        IDManager.SetID(headerIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        headerIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        header = new ResponseMessageHeader(item);
                    }
                }
            }


            XmlNodeList validationNodeList = xmlNode.SelectNodes("validation");

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


            XmlNodeList parentCorrelationIdNodeList = xmlNode.SelectNodes("parentCorrelationId");

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

            foreach (XmlNode item in parentCorrelationIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        parentCorrelationIdIDRef = item.Attributes["id"].Name;
                        CorrelationId ob = CorrelationId();
                        IDManager.SetID(parentCorrelationIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        parentCorrelationIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        parentCorrelationId = new CorrelationId(item);
                    }
                }
            }


            XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");

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

            foreach (XmlNode item in correlationIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        correlationIdIDRef = item.Attributes["id"].Name;
                        CorrelationId ob = CorrelationId();
                        IDManager.SetID(correlationIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        correlationIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        correlationId = new CorrelationId(item);
                    }
                }
            }


            XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");

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

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


            XmlNodeList onBehalfOfNodeList = xmlNode.SelectNodes("onBehalfOf");

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

            foreach (XmlNode item in onBehalfOfNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        onBehalfOfIDRef = item.Attributes["id"].Name;
                        OnBehalfOf ob = OnBehalfOf();
                        IDManager.SetID(onBehalfOfIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        onBehalfOfIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        onBehalfOf = new OnBehalfOf(item);
                    }
                }
            }
        }
 public PubliclyAvailableInformation(XmlNode xmlNode)
 {
     XmlNode standardPublicSourcesNode = xmlNode.SelectSingleNode("standardPublicSources");
     
     if (standardPublicSourcesNode != null)
     {
         if (standardPublicSourcesNode.Attributes["href"] != null || standardPublicSourcesNode.Attributes["id"] != null) 
         {
             if (standardPublicSourcesNode.Attributes["id"] != null) 
             {
                 standardPublicSourcesIDRef_ = standardPublicSourcesNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(standardPublicSourcesNode);
                 IDManager.SetID(standardPublicSourcesIDRef_, ob);
             }
             else if (standardPublicSourcesNode.Attributes["href"] != null)
             {
                 standardPublicSourcesIDRef_ = standardPublicSourcesNode.Attributes["href"].Value;
             }
             else
             {
                 standardPublicSources_ = new XsdTypeBoolean(standardPublicSourcesNode);
             }
         }
         else
         {
             standardPublicSources_ = new XsdTypeBoolean(standardPublicSourcesNode);
         }
     }
     
 
     XmlNodeList publicSourceNodeList = xmlNode.SelectNodes("publicSource");
     
     if (publicSourceNodeList != null)
     {
         this.publicSource_ = new List<XsdTypeString>();
         foreach (XmlNode item in publicSourceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     publicSourceIDRef_ = item.Attributes["id"].Value;
                     publicSource_.Add(new XsdTypeString(item));
                     IDManager.SetID(publicSourceIDRef_, publicSource_[publicSource_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     publicSourceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 publicSource_.Add(new XsdTypeString(item));
                 }
             }
             else
             {
                 publicSource_.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNode specifiedNumberNode = xmlNode.SelectSingleNode("specifiedNumber");
     
     if (specifiedNumberNode != null)
     {
         if (specifiedNumberNode.Attributes["href"] != null || specifiedNumberNode.Attributes["id"] != null) 
         {
             if (specifiedNumberNode.Attributes["id"] != null) 
             {
                 specifiedNumberIDRef_ = specifiedNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(specifiedNumberNode);
                 IDManager.SetID(specifiedNumberIDRef_, ob);
             }
             else if (specifiedNumberNode.Attributes["href"] != null)
             {
                 specifiedNumberIDRef_ = specifiedNumberNode.Attributes["href"].Value;
             }
             else
             {
                 specifiedNumber_ = new XsdTypePositiveInteger(specifiedNumberNode);
             }
         }
         else
         {
             specifiedNumber_ = new XsdTypePositiveInteger(specifiedNumberNode);
         }
     }
     
 
 }