コード例 #1
0
        public SingleValuationDate(XmlNode xmlNode)
        {
            XmlNodeList businessDaysNodeList = xmlNode.SelectNodes("businessDays");

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

            foreach (XmlNode item in businessDaysNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        businessDaysIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(businessDaysIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        businessDaysIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        businessDays = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #2
0
 public SingleValuationDate(XmlNode xmlNode)
 {
     XmlNode businessDaysNode = xmlNode.SelectSingleNode("businessDays");
     
     if (businessDaysNode != null)
     {
         if (businessDaysNode.Attributes["href"] != null || businessDaysNode.Attributes["id"] != null) 
         {
             if (businessDaysNode.Attributes["id"] != null) 
             {
                 businessDaysIDRef_ = businessDaysNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(businessDaysNode);
                 IDManager.SetID(businessDaysIDRef_, ob);
             }
             else if (businessDaysNode.Attributes["href"] != null)
             {
                 businessDaysIDRef_ = businessDaysNode.Attributes["href"].Value;
             }
             else
             {
                 businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
             }
         }
         else
         {
             businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
         }
     }
     
 
 }
コード例 #3
0
        public SingleValuationDate(XmlNode xmlNode)
        {
            XmlNode businessDaysNode = xmlNode.SelectSingleNode("businessDays");

            if (businessDaysNode != null)
            {
                if (businessDaysNode.Attributes["href"] != null || businessDaysNode.Attributes["id"] != null)
                {
                    if (businessDaysNode.Attributes["id"] != null)
                    {
                        businessDaysIDRef_ = businessDaysNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(businessDaysNode);
                        IDManager.SetID(businessDaysIDRef_, ob);
                    }
                    else if (businessDaysNode.Attributes["href"] != null)
                    {
                        businessDaysIDRef_ = businessDaysNode.Attributes["href"].Value;
                    }
                    else
                    {
                        businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
                    }
                }
                else
                {
                    businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
                }
            }
        }
コード例 #4
0
 public Rounding(XmlNode xmlNode)
 {
     XmlNode roundingDirectionNode = xmlNode.SelectSingleNode("roundingDirection");
     
     if (roundingDirectionNode != null)
     {
         if (roundingDirectionNode.Attributes["href"] != null || roundingDirectionNode.Attributes["id"] != null) 
         {
             if (roundingDirectionNode.Attributes["id"] != null) 
             {
                 roundingDirectionIDRef_ = roundingDirectionNode.Attributes["id"].Value;
                 RoundingDirectionEnum ob = new RoundingDirectionEnum(roundingDirectionNode);
                 IDManager.SetID(roundingDirectionIDRef_, ob);
             }
             else if (roundingDirectionNode.Attributes["href"] != null)
             {
                 roundingDirectionIDRef_ = roundingDirectionNode.Attributes["href"].Value;
             }
             else
             {
                 roundingDirection_ = new RoundingDirectionEnum(roundingDirectionNode);
             }
         }
         else
         {
             roundingDirection_ = new RoundingDirectionEnum(roundingDirectionNode);
         }
     }
     
 
     XmlNode precisionNode = xmlNode.SelectSingleNode("precision");
     
     if (precisionNode != null)
     {
         if (precisionNode.Attributes["href"] != null || precisionNode.Attributes["id"] != null) 
         {
             if (precisionNode.Attributes["id"] != null) 
             {
                 precisionIDRef_ = precisionNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(precisionNode);
                 IDManager.SetID(precisionIDRef_, ob);
             }
             else if (precisionNode.Attributes["href"] != null)
             {
                 precisionIDRef_ = precisionNode.Attributes["href"].Value;
             }
             else
             {
                 precision_ = new XsdTypeNonNegativeInteger(precisionNode);
             }
         }
         else
         {
             precision_ = new XsdTypeNonNegativeInteger(precisionNode);
         }
     }
     
 
 }
 public AverageDailyTradingVolumeLimit(XmlNode xmlNode)
 {
     XmlNode limitationPercentageNode = xmlNode.SelectSingleNode("limitationPercentage");
     
     if (limitationPercentageNode != null)
     {
         if (limitationPercentageNode.Attributes["href"] != null || limitationPercentageNode.Attributes["id"] != null) 
         {
             if (limitationPercentageNode.Attributes["id"] != null) 
             {
                 limitationPercentageIDRef_ = limitationPercentageNode.Attributes["id"].Value;
                 RestrictedPercentage ob = new RestrictedPercentage(limitationPercentageNode);
                 IDManager.SetID(limitationPercentageIDRef_, ob);
             }
             else if (limitationPercentageNode.Attributes["href"] != null)
             {
                 limitationPercentageIDRef_ = limitationPercentageNode.Attributes["href"].Value;
             }
             else
             {
                 limitationPercentage_ = new RestrictedPercentage(limitationPercentageNode);
             }
         }
         else
         {
             limitationPercentage_ = new RestrictedPercentage(limitationPercentageNode);
         }
     }
     
 
     XmlNode limitationPeriodNode = xmlNode.SelectSingleNode("limitationPeriod");
     
     if (limitationPeriodNode != null)
     {
         if (limitationPeriodNode.Attributes["href"] != null || limitationPeriodNode.Attributes["id"] != null) 
         {
             if (limitationPeriodNode.Attributes["id"] != null) 
             {
                 limitationPeriodIDRef_ = limitationPeriodNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(limitationPeriodNode);
                 IDManager.SetID(limitationPeriodIDRef_, ob);
             }
             else if (limitationPeriodNode.Attributes["href"] != null)
             {
                 limitationPeriodIDRef_ = limitationPeriodNode.Attributes["href"].Value;
             }
             else
             {
                 limitationPeriod_ = new XsdTypeNonNegativeInteger(limitationPeriodNode);
             }
         }
         else
         {
             limitationPeriod_ = new XsdTypeNonNegativeInteger(limitationPeriodNode);
         }
     }
     
 
 }
コード例 #6
0
        public Rounding(XmlNode xmlNode)
        {
            XmlNodeList roundingDirectionNodeList = xmlNode.SelectNodes("roundingDirection");

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

            foreach (XmlNode item in roundingDirectionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        roundingDirectionIDRef = item.Attributes["id"].Name;
                        RoundingDirectionEnum ob = RoundingDirectionEnum();
                        IDManager.SetID(roundingDirectionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        roundingDirectionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        roundingDirection = new RoundingDirectionEnum(item);
                    }
                }
            }


            XmlNodeList precisionNodeList = xmlNode.SelectNodes("precision");

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

            foreach (XmlNode item in precisionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        precisionIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(precisionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        precisionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        precision = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #7
0
        public AverageDailyTradingVolumeLimit(XmlNode xmlNode)
        {
            XmlNodeList limitationPercentageNodeList = xmlNode.SelectNodes("limitationPercentage");

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

            foreach (XmlNode item in limitationPercentageNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        limitationPercentageIDRef = item.Attributes["id"].Name;
                        RestrictedPercentage ob = RestrictedPercentage();
                        IDManager.SetID(limitationPercentageIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        limitationPercentageIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        limitationPercentage = new RestrictedPercentage(item);
                    }
                }
            }


            XmlNodeList limitationPeriodNodeList = xmlNode.SelectNodes("limitationPeriod");

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

            foreach (XmlNode item in limitationPeriodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        limitationPeriodIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(limitationPeriodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        limitationPeriodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        limitationPeriod = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #8
0
        public Rounding(XmlNode xmlNode)
        {
            XmlNode roundingDirectionNode = xmlNode.SelectSingleNode("roundingDirection");

            if (roundingDirectionNode != null)
            {
                if (roundingDirectionNode.Attributes["href"] != null || roundingDirectionNode.Attributes["id"] != null)
                {
                    if (roundingDirectionNode.Attributes["id"] != null)
                    {
                        roundingDirectionIDRef_ = roundingDirectionNode.Attributes["id"].Value;
                        RoundingDirectionEnum ob = new RoundingDirectionEnum(roundingDirectionNode);
                        IDManager.SetID(roundingDirectionIDRef_, ob);
                    }
                    else if (roundingDirectionNode.Attributes["href"] != null)
                    {
                        roundingDirectionIDRef_ = roundingDirectionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        roundingDirection_ = new RoundingDirectionEnum(roundingDirectionNode);
                    }
                }
                else
                {
                    roundingDirection_ = new RoundingDirectionEnum(roundingDirectionNode);
                }
            }


            XmlNode precisionNode = xmlNode.SelectSingleNode("precision");

            if (precisionNode != null)
            {
                if (precisionNode.Attributes["href"] != null || precisionNode.Attributes["id"] != null)
                {
                    if (precisionNode.Attributes["id"] != null)
                    {
                        precisionIDRef_ = precisionNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(precisionNode);
                        IDManager.SetID(precisionIDRef_, ob);
                    }
                    else if (precisionNode.Attributes["href"] != null)
                    {
                        precisionIDRef_ = precisionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        precision_ = new XsdTypeNonNegativeInteger(precisionNode);
                    }
                }
                else
                {
                    precision_ = new XsdTypeNonNegativeInteger(precisionNode);
                }
            }
        }
        public AverageDailyTradingVolumeLimit(XmlNode xmlNode)
        {
            XmlNode limitationPercentageNode = xmlNode.SelectSingleNode("limitationPercentage");

            if (limitationPercentageNode != null)
            {
                if (limitationPercentageNode.Attributes["href"] != null || limitationPercentageNode.Attributes["id"] != null)
                {
                    if (limitationPercentageNode.Attributes["id"] != null)
                    {
                        limitationPercentageIDRef_ = limitationPercentageNode.Attributes["id"].Value;
                        RestrictedPercentage ob = new RestrictedPercentage(limitationPercentageNode);
                        IDManager.SetID(limitationPercentageIDRef_, ob);
                    }
                    else if (limitationPercentageNode.Attributes["href"] != null)
                    {
                        limitationPercentageIDRef_ = limitationPercentageNode.Attributes["href"].Value;
                    }
                    else
                    {
                        limitationPercentage_ = new RestrictedPercentage(limitationPercentageNode);
                    }
                }
                else
                {
                    limitationPercentage_ = new RestrictedPercentage(limitationPercentageNode);
                }
            }


            XmlNode limitationPeriodNode = xmlNode.SelectSingleNode("limitationPeriod");

            if (limitationPeriodNode != null)
            {
                if (limitationPeriodNode.Attributes["href"] != null || limitationPeriodNode.Attributes["id"] != null)
                {
                    if (limitationPeriodNode.Attributes["id"] != null)
                    {
                        limitationPeriodIDRef_ = limitationPeriodNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(limitationPeriodNode);
                        IDManager.SetID(limitationPeriodIDRef_, ob);
                    }
                    else if (limitationPeriodNode.Attributes["href"] != null)
                    {
                        limitationPeriodIDRef_ = limitationPeriodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        limitationPeriod_ = new XsdTypeNonNegativeInteger(limitationPeriodNode);
                    }
                }
                else
                {
                    limitationPeriod_ = new XsdTypeNonNegativeInteger(limitationPeriodNode);
                }
            }
        }
コード例 #10
0
        public EquityValuation(XmlNode xmlNode)
        {
            XmlNodeList valuationDateNodeList = xmlNode.SelectNodes("valuationDate");

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

            foreach (XmlNode item in valuationDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationDateIDRef = item.Attributes["id"].Name;
                        AdjustableDateOrRelativeDateSequence ob = AdjustableDateOrRelativeDateSequence();
                        IDManager.SetID(valuationDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationDate = new AdjustableDateOrRelativeDateSequence(item);
                    }
                }
            }


            XmlNodeList valuationDatesNodeList = xmlNode.SelectNodes("valuationDates");

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

            foreach (XmlNode item in valuationDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationDatesIDRef = item.Attributes["id"].Name;
                        AdjustableRelativeOrPeriodicDates ob = AdjustableRelativeOrPeriodicDates();
                        IDManager.SetID(valuationDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationDates = new AdjustableRelativeOrPeriodicDates(item);
                    }
                }
            }


            XmlNodeList valuationTimeTypeNodeList = xmlNode.SelectNodes("valuationTimeType");

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

            foreach (XmlNode item in valuationTimeTypeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationTimeTypeIDRef = item.Attributes["id"].Name;
                        TimeTypeEnum ob = TimeTypeEnum();
                        IDManager.SetID(valuationTimeTypeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationTimeTypeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationTimeType = new TimeTypeEnum(item);
                    }
                }
            }


            XmlNodeList valuationTimeNodeList = xmlNode.SelectNodes("valuationTime");

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

            foreach (XmlNode item in valuationTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationTimeIDRef = item.Attributes["id"].Name;
                        BusinessCenterTime ob = BusinessCenterTime();
                        IDManager.SetID(valuationTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationTime = new BusinessCenterTime(item);
                    }
                }
            }


            XmlNodeList futuresPriceValuationNodeList = xmlNode.SelectNodes("futuresPriceValuation");

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

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


            XmlNodeList optionsPriceValuationNodeList = xmlNode.SelectNodes("optionsPriceValuation");

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

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


            XmlNodeList numberOfValuationDatesNodeList = xmlNode.SelectNodes("numberOfValuationDates");

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

            foreach (XmlNode item in numberOfValuationDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        numberOfValuationDatesIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(numberOfValuationDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        numberOfValuationDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        numberOfValuationDates = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList dividendValuationDatesNodeList = xmlNode.SelectNodes("dividendValuationDates");

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

            foreach (XmlNode item in dividendValuationDatesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        dividendValuationDatesIDRef = item.Attributes["id"].Name;
                        AdjustableRelativeOrPeriodicDates ob = AdjustableRelativeOrPeriodicDates();
                        IDManager.SetID(dividendValuationDatesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        dividendValuationDatesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        dividendValuationDates = new AdjustableRelativeOrPeriodicDates(item);
                    }
                }
            }


            XmlNodeList fPVFinalPriceElectionFallbackNodeList = xmlNode.SelectNodes("fPVFinalPriceElectionFallback");

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

            foreach (XmlNode item in fPVFinalPriceElectionFallbackNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fPVFinalPriceElectionFallbackIDRef = item.Attributes["id"].Name;
                        FPVFinalPriceElectionFallbackEnum ob = FPVFinalPriceElectionFallbackEnum();
                        IDManager.SetID(fPVFinalPriceElectionFallbackIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fPVFinalPriceElectionFallbackIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fPVFinalPriceElectionFallback = new FPVFinalPriceElectionFallbackEnum(item);
                    }
                }
            }
        }
コード例 #11
0
        public VersionedContractId(XmlNode xmlNode)
        {
            XmlNode contractIdNode = xmlNode.SelectSingleNode("contractId");

            if (contractIdNode != null)
            {
                if (contractIdNode.Attributes["href"] != null || contractIdNode.Attributes["id"] != null)
                {
                    if (contractIdNode.Attributes["id"] != null)
                    {
                        contractIdIDRef_ = contractIdNode.Attributes["id"].Value;
                        ContractId ob = new ContractId(contractIdNode);
                        IDManager.SetID(contractIdIDRef_, ob);
                    }
                    else if (contractIdNode.Attributes["href"] != null)
                    {
                        contractIdIDRef_ = contractIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        contractId_ = new ContractId(contractIdNode);
                    }
                }
                else
                {
                    contractId_ = new ContractId(contractIdNode);
                }
            }


            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;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(versionNode);
                        IDManager.SetID(versionIDRef_, ob);
                    }
                    else if (versionNode.Attributes["href"] != null)
                    {
                        versionIDRef_ = versionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        version_ = new XsdTypeNonNegativeInteger(versionNode);
                    }
                }
                else
                {
                    version_ = new XsdTypeNonNegativeInteger(versionNode);
                }
            }


            XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");

            if (effectiveDateNode != null)
            {
                if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null)
                {
                    if (effectiveDateNode.Attributes["id"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                        IdentifiedDate ob = new IdentifiedDate(effectiveDateNode);
                        IDManager.SetID(effectiveDateIDRef_, ob);
                    }
                    else if (effectiveDateNode.Attributes["href"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                    }
                }
                else
                {
                    effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                }
            }
        }
コード例 #12
0
        public CommodityMarketDisruption(XmlNode xmlNode)
        {
            XmlNodeList marketDisruptionEventsNodeList = xmlNode.SelectNodes("marketDisruptionEvents");

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

            foreach (XmlNode item in marketDisruptionEventsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        marketDisruptionEventsIDRef = item.Attributes["id"].Name;
                        MarketDisruptionEventsEnum ob = MarketDisruptionEventsEnum();
                        IDManager.SetID(marketDisruptionEventsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        marketDisruptionEventsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        marketDisruptionEvents = new MarketDisruptionEventsEnum(item);
                    }
                }
            }


            XmlNodeList additionalMarketDisruptionEventNodeList = xmlNode.SelectNodes("additionalMarketDisruptionEvent");

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


            XmlNodeList marketDisruptionEventNodeList = xmlNode.SelectNodes("marketDisruptionEvent");

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


            XmlNodeList disruptionFallbacksNodeList = xmlNode.SelectNodes("disruptionFallbacks");

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

            foreach (XmlNode item in disruptionFallbacksNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        disruptionFallbacksIDRef = item.Attributes["id"].Name;
                        DisruptionFallbacksEnum ob = DisruptionFallbacksEnum();
                        IDManager.SetID(disruptionFallbacksIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        disruptionFallbacksIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        disruptionFallbacks = new DisruptionFallbacksEnum(item);
                    }
                }
            }


            XmlNodeList disruptionFallbackNodeList = xmlNode.SelectNodes("disruptionFallback");

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


            XmlNodeList fallbackReferencePriceNodeList = xmlNode.SelectNodes("fallbackReferencePrice");

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

            foreach (XmlNode item in fallbackReferencePriceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fallbackReferencePriceIDRef = item.Attributes["id"].Name;
                        Underlyer ob = Underlyer();
                        IDManager.SetID(fallbackReferencePriceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fallbackReferencePriceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fallbackReferencePrice = new Underlyer(item);
                    }
                }
            }


            XmlNodeList maximumNumberOfDaysOfDisruptionNodeList = xmlNode.SelectNodes("maximumNumberOfDaysOfDisruption");

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

            foreach (XmlNode item in maximumNumberOfDaysOfDisruptionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(maximumNumberOfDaysOfDisruptionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        maximumNumberOfDaysOfDisruptionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        maximumNumberOfDaysOfDisruption = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList priceMaterialityPercentageNodeList = xmlNode.SelectNodes("priceMaterialityPercentage");

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

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


            XmlNodeList minimumFuturesContractsNodeList = xmlNode.SelectNodes("minimumFuturesContracts");

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

            foreach (XmlNode item in minimumFuturesContractsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        minimumFuturesContractsIDRef = item.Attributes["id"].Name;
                        XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                        IDManager.SetID(minimumFuturesContractsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        minimumFuturesContractsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        minimumFuturesContracts = new XsdTypePositiveInteger(item);
                    }
                }
            }
        }
コード例 #13
0
 public EquityValuation(XmlNode xmlNode)
 {
     XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");
     
     if (valuationDateNode != null)
     {
         if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null) 
         {
             if (valuationDateNode.Attributes["id"] != null) 
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                 AdjustableDateOrRelativeDateSequence ob = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
                 IDManager.SetID(valuationDateIDRef_, ob);
             }
             else if (valuationDateNode.Attributes["href"] != null)
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
             }
             else
             {
                 valuationDate_ = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
             }
         }
         else
         {
             valuationDate_ = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
         }
     }
     
 
     XmlNode valuationDatesNode = xmlNode.SelectSingleNode("valuationDates");
     
     if (valuationDatesNode != null)
     {
         if (valuationDatesNode.Attributes["href"] != null || valuationDatesNode.Attributes["id"] != null) 
         {
             if (valuationDatesNode.Attributes["id"] != null) 
             {
                 valuationDatesIDRef_ = valuationDatesNode.Attributes["id"].Value;
                 AdjustableRelativeOrPeriodicDates ob = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
                 IDManager.SetID(valuationDatesIDRef_, ob);
             }
             else if (valuationDatesNode.Attributes["href"] != null)
             {
                 valuationDatesIDRef_ = valuationDatesNode.Attributes["href"].Value;
             }
             else
             {
                 valuationDates_ = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
             }
         }
         else
         {
             valuationDates_ = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
         }
     }
     
 
     XmlNode valuationTimeTypeNode = xmlNode.SelectSingleNode("valuationTimeType");
     
     if (valuationTimeTypeNode != null)
     {
         if (valuationTimeTypeNode.Attributes["href"] != null || valuationTimeTypeNode.Attributes["id"] != null) 
         {
             if (valuationTimeTypeNode.Attributes["id"] != null) 
             {
                 valuationTimeTypeIDRef_ = valuationTimeTypeNode.Attributes["id"].Value;
                 TimeTypeEnum ob = new TimeTypeEnum(valuationTimeTypeNode);
                 IDManager.SetID(valuationTimeTypeIDRef_, ob);
             }
             else if (valuationTimeTypeNode.Attributes["href"] != null)
             {
                 valuationTimeTypeIDRef_ = valuationTimeTypeNode.Attributes["href"].Value;
             }
             else
             {
                 valuationTimeType_ = new TimeTypeEnum(valuationTimeTypeNode);
             }
         }
         else
         {
             valuationTimeType_ = new TimeTypeEnum(valuationTimeTypeNode);
         }
     }
     
 
     XmlNode valuationTimeNode = xmlNode.SelectSingleNode("valuationTime");
     
     if (valuationTimeNode != null)
     {
         if (valuationTimeNode.Attributes["href"] != null || valuationTimeNode.Attributes["id"] != null) 
         {
             if (valuationTimeNode.Attributes["id"] != null) 
             {
                 valuationTimeIDRef_ = valuationTimeNode.Attributes["id"].Value;
                 BusinessCenterTime ob = new BusinessCenterTime(valuationTimeNode);
                 IDManager.SetID(valuationTimeIDRef_, ob);
             }
             else if (valuationTimeNode.Attributes["href"] != null)
             {
                 valuationTimeIDRef_ = valuationTimeNode.Attributes["href"].Value;
             }
             else
             {
                 valuationTime_ = new BusinessCenterTime(valuationTimeNode);
             }
         }
         else
         {
             valuationTime_ = new BusinessCenterTime(valuationTimeNode);
         }
     }
     
 
     XmlNode futuresPriceValuationNode = xmlNode.SelectSingleNode("futuresPriceValuation");
     
     if (futuresPriceValuationNode != null)
     {
         if (futuresPriceValuationNode.Attributes["href"] != null || futuresPriceValuationNode.Attributes["id"] != null) 
         {
             if (futuresPriceValuationNode.Attributes["id"] != null) 
             {
                 futuresPriceValuationIDRef_ = futuresPriceValuationNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(futuresPriceValuationNode);
                 IDManager.SetID(futuresPriceValuationIDRef_, ob);
             }
             else if (futuresPriceValuationNode.Attributes["href"] != null)
             {
                 futuresPriceValuationIDRef_ = futuresPriceValuationNode.Attributes["href"].Value;
             }
             else
             {
                 futuresPriceValuation_ = new XsdTypeBoolean(futuresPriceValuationNode);
             }
         }
         else
         {
             futuresPriceValuation_ = new XsdTypeBoolean(futuresPriceValuationNode);
         }
     }
     
 
     XmlNode optionsPriceValuationNode = xmlNode.SelectSingleNode("optionsPriceValuation");
     
     if (optionsPriceValuationNode != null)
     {
         if (optionsPriceValuationNode.Attributes["href"] != null || optionsPriceValuationNode.Attributes["id"] != null) 
         {
             if (optionsPriceValuationNode.Attributes["id"] != null) 
             {
                 optionsPriceValuationIDRef_ = optionsPriceValuationNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(optionsPriceValuationNode);
                 IDManager.SetID(optionsPriceValuationIDRef_, ob);
             }
             else if (optionsPriceValuationNode.Attributes["href"] != null)
             {
                 optionsPriceValuationIDRef_ = optionsPriceValuationNode.Attributes["href"].Value;
             }
             else
             {
                 optionsPriceValuation_ = new XsdTypeBoolean(optionsPriceValuationNode);
             }
         }
         else
         {
             optionsPriceValuation_ = new XsdTypeBoolean(optionsPriceValuationNode);
         }
     }
     
 
     XmlNode numberOfValuationDatesNode = xmlNode.SelectSingleNode("numberOfValuationDates");
     
     if (numberOfValuationDatesNode != null)
     {
         if (numberOfValuationDatesNode.Attributes["href"] != null || numberOfValuationDatesNode.Attributes["id"] != null) 
         {
             if (numberOfValuationDatesNode.Attributes["id"] != null) 
             {
                 numberOfValuationDatesIDRef_ = numberOfValuationDatesNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
                 IDManager.SetID(numberOfValuationDatesIDRef_, ob);
             }
             else if (numberOfValuationDatesNode.Attributes["href"] != null)
             {
                 numberOfValuationDatesIDRef_ = numberOfValuationDatesNode.Attributes["href"].Value;
             }
             else
             {
                 numberOfValuationDates_ = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
             }
         }
         else
         {
             numberOfValuationDates_ = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
         }
     }
     
 
     XmlNode dividendValuationDatesNode = xmlNode.SelectSingleNode("dividendValuationDates");
     
     if (dividendValuationDatesNode != null)
     {
         if (dividendValuationDatesNode.Attributes["href"] != null || dividendValuationDatesNode.Attributes["id"] != null) 
         {
             if (dividendValuationDatesNode.Attributes["id"] != null) 
             {
                 dividendValuationDatesIDRef_ = dividendValuationDatesNode.Attributes["id"].Value;
                 AdjustableRelativeOrPeriodicDates ob = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
                 IDManager.SetID(dividendValuationDatesIDRef_, ob);
             }
             else if (dividendValuationDatesNode.Attributes["href"] != null)
             {
                 dividendValuationDatesIDRef_ = dividendValuationDatesNode.Attributes["href"].Value;
             }
             else
             {
                 dividendValuationDates_ = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
             }
         }
         else
         {
             dividendValuationDates_ = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
         }
     }
     
 
     XmlNode fPVFinalPriceElectionFallbackNode = xmlNode.SelectSingleNode("fPVFinalPriceElectionFallback");
     
     if (fPVFinalPriceElectionFallbackNode != null)
     {
         if (fPVFinalPriceElectionFallbackNode.Attributes["href"] != null || fPVFinalPriceElectionFallbackNode.Attributes["id"] != null) 
         {
             if (fPVFinalPriceElectionFallbackNode.Attributes["id"] != null) 
             {
                 fPVFinalPriceElectionFallbackIDRef_ = fPVFinalPriceElectionFallbackNode.Attributes["id"].Value;
                 FPVFinalPriceElectionFallbackEnum ob = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
                 IDManager.SetID(fPVFinalPriceElectionFallbackIDRef_, ob);
             }
             else if (fPVFinalPriceElectionFallbackNode.Attributes["href"] != null)
             {
                 fPVFinalPriceElectionFallbackIDRef_ = fPVFinalPriceElectionFallbackNode.Attributes["href"].Value;
             }
             else
             {
                 fPVFinalPriceElectionFallback_ = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
             }
         }
         else
         {
             fPVFinalPriceElectionFallback_ = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
         }
     }
     
 
 }
        public PhysicalSettlementPeriod(XmlNode xmlNode)
        {
            XmlNodeList businessDaysNotSpecifiedNodeList = xmlNode.SelectNodes("businessDaysNotSpecified");

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

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


            XmlNodeList businessDaysNodeList = xmlNode.SelectNodes("businessDays");

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

            foreach (XmlNode item in businessDaysNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        businessDaysIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(businessDaysIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        businessDaysIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        businessDays = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList maximumBusinessDaysNodeList = xmlNode.SelectNodes("maximumBusinessDays");

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

            foreach (XmlNode item in maximumBusinessDaysNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        maximumBusinessDaysIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(maximumBusinessDaysIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        maximumBusinessDaysIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        maximumBusinessDays = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #15
0
        public AssetPool(XmlNode xmlNode)
        {
            XmlNodeList versionNodeList = xmlNode.SelectNodes("version");

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

            foreach (XmlNode item in versionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        versionIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(versionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        versionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        version = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");

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

            foreach (XmlNode item in effectiveDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        effectiveDateIDRef = item.Attributes["id"].Name;
                        IdentifiedDate ob = IdentifiedDate();
                        IDManager.SetID(effectiveDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        effectiveDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        effectiveDate = new IdentifiedDate(item);
                    }
                }
            }


            XmlNodeList initialFactorNodeList = xmlNode.SelectNodes("initialFactor");

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

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


            XmlNodeList currentFactorNodeList = xmlNode.SelectNodes("currentFactor");

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

            foreach (XmlNode item in currentFactorNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        currentFactorIDRef = item.Attributes["id"].Name;
                        XsdTypeDecimal ob = XsdTypeDecimal();
                        IDManager.SetID(currentFactorIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        currentFactorIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        currentFactor = new XsdTypeDecimal(item);
                    }
                }
            }
        }
コード例 #16
0
 public PartialExercise(XmlNode xmlNode)
 {
     XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");
     
     if (notionalReferenceNodeList != null)
     {
         this.notionalReference_ = new List<NotionalReference>();
         foreach (XmlNode item in notionalReferenceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     notionalReferenceIDRef_ = item.Attributes["id"].Value;
                     notionalReference_.Add(new NotionalReference(item));
                     IDManager.SetID(notionalReferenceIDRef_, notionalReference_[notionalReference_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     notionalReferenceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 notionalReference_.Add(new NotionalReference(item));
                 }
             }
             else
             {
                 notionalReference_.Add(new NotionalReference(item));
             }
         }
     }
     
 
     XmlNode integralMultipleAmountNode = xmlNode.SelectSingleNode("integralMultipleAmount");
     
     if (integralMultipleAmountNode != null)
     {
         if (integralMultipleAmountNode.Attributes["href"] != null || integralMultipleAmountNode.Attributes["id"] != null) 
         {
             if (integralMultipleAmountNode.Attributes["id"] != null) 
             {
                 integralMultipleAmountIDRef_ = integralMultipleAmountNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(integralMultipleAmountNode);
                 IDManager.SetID(integralMultipleAmountIDRef_, ob);
             }
             else if (integralMultipleAmountNode.Attributes["href"] != null)
             {
                 integralMultipleAmountIDRef_ = integralMultipleAmountNode.Attributes["href"].Value;
             }
             else
             {
                 integralMultipleAmount_ = new XsdTypeDecimal(integralMultipleAmountNode);
             }
         }
         else
         {
             integralMultipleAmount_ = new XsdTypeDecimal(integralMultipleAmountNode);
         }
     }
     
 
     XmlNode minimumNotionalAmountNode = xmlNode.SelectSingleNode("minimumNotionalAmount");
     
     if (minimumNotionalAmountNode != null)
     {
         if (minimumNotionalAmountNode.Attributes["href"] != null || minimumNotionalAmountNode.Attributes["id"] != null) 
         {
             if (minimumNotionalAmountNode.Attributes["id"] != null) 
             {
                 minimumNotionalAmountIDRef_ = minimumNotionalAmountNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(minimumNotionalAmountNode);
                 IDManager.SetID(minimumNotionalAmountIDRef_, ob);
             }
             else if (minimumNotionalAmountNode.Attributes["href"] != null)
             {
                 minimumNotionalAmountIDRef_ = minimumNotionalAmountNode.Attributes["href"].Value;
             }
             else
             {
                 minimumNotionalAmount_ = new XsdTypeDecimal(minimumNotionalAmountNode);
             }
         }
         else
         {
             minimumNotionalAmount_ = new XsdTypeDecimal(minimumNotionalAmountNode);
         }
     }
     
 
     XmlNode minimumNumberOfOptionsNode = xmlNode.SelectSingleNode("minimumNumberOfOptions");
     
     if (minimumNumberOfOptionsNode != null)
     {
         if (minimumNumberOfOptionsNode.Attributes["href"] != null || minimumNumberOfOptionsNode.Attributes["id"] != null) 
         {
             if (minimumNumberOfOptionsNode.Attributes["id"] != null) 
             {
                 minimumNumberOfOptionsIDRef_ = minimumNumberOfOptionsNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
                 IDManager.SetID(minimumNumberOfOptionsIDRef_, ob);
             }
             else if (minimumNumberOfOptionsNode.Attributes["href"] != null)
             {
                 minimumNumberOfOptionsIDRef_ = minimumNumberOfOptionsNode.Attributes["href"].Value;
             }
             else
             {
                 minimumNumberOfOptions_ = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
             }
         }
         else
         {
             minimumNumberOfOptions_ = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
         }
     }
     
 
 }
        public PhysicalSettlementPeriod(XmlNode xmlNode)
        {
            XmlNode businessDaysNotSpecifiedNode = xmlNode.SelectSingleNode("businessDaysNotSpecified");

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


            XmlNode businessDaysNode = xmlNode.SelectSingleNode("businessDays");

            if (businessDaysNode != null)
            {
                if (businessDaysNode.Attributes["href"] != null || businessDaysNode.Attributes["id"] != null)
                {
                    if (businessDaysNode.Attributes["id"] != null)
                    {
                        businessDaysIDRef_ = businessDaysNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(businessDaysNode);
                        IDManager.SetID(businessDaysIDRef_, ob);
                    }
                    else if (businessDaysNode.Attributes["href"] != null)
                    {
                        businessDaysIDRef_ = businessDaysNode.Attributes["href"].Value;
                    }
                    else
                    {
                        businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
                    }
                }
                else
                {
                    businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
                }
            }


            XmlNode maximumBusinessDaysNode = xmlNode.SelectSingleNode("maximumBusinessDays");

            if (maximumBusinessDaysNode != null)
            {
                if (maximumBusinessDaysNode.Attributes["href"] != null || maximumBusinessDaysNode.Attributes["id"] != null)
                {
                    if (maximumBusinessDaysNode.Attributes["id"] != null)
                    {
                        maximumBusinessDaysIDRef_ = maximumBusinessDaysNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
                        IDManager.SetID(maximumBusinessDaysIDRef_, ob);
                    }
                    else if (maximumBusinessDaysNode.Attributes["href"] != null)
                    {
                        maximumBusinessDaysIDRef_ = maximumBusinessDaysNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumBusinessDays_ = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
                    }
                }
                else
                {
                    maximumBusinessDays_ = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
                }
            }
        }
コード例 #18
0
 public FxAsianFeature(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 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);
         }
     }
     
 
     XmlNode observationScheduleNode = xmlNode.SelectSingleNode("observationSchedule");
     
     if (observationScheduleNode != null)
     {
         if (observationScheduleNode.Attributes["href"] != null || observationScheduleNode.Attributes["id"] != null) 
         {
             if (observationScheduleNode.Attributes["id"] != null) 
             {
                 observationScheduleIDRef_ = observationScheduleNode.Attributes["id"].Value;
                 FxAverageRateObservationSchedule ob = new FxAverageRateObservationSchedule(observationScheduleNode);
                 IDManager.SetID(observationScheduleIDRef_, ob);
             }
             else if (observationScheduleNode.Attributes["href"] != null)
             {
                 observationScheduleIDRef_ = observationScheduleNode.Attributes["href"].Value;
             }
             else
             {
                 observationSchedule_ = new FxAverageRateObservationSchedule(observationScheduleNode);
             }
         }
         else
         {
             observationSchedule_ = new FxAverageRateObservationSchedule(observationScheduleNode);
         }
     }
     
 
     XmlNodeList rateObservationNodeList = xmlNode.SelectNodes("rateObservation");
     
     if (rateObservationNodeList != null)
     {
         this.rateObservation_ = new List<FxAverageRateObservation>();
         foreach (XmlNode item in rateObservationNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     rateObservationIDRef_ = item.Attributes["id"].Value;
                     rateObservation_.Add(new FxAverageRateObservation(item));
                     IDManager.SetID(rateObservationIDRef_, rateObservation_[rateObservation_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     rateObservationIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 rateObservation_.Add(new FxAverageRateObservation(item));
                 }
             }
             else
             {
                 rateObservation_.Add(new FxAverageRateObservation(item));
             }
         }
     }
     
 
     XmlNode rateObservationQuoteBasisNode = xmlNode.SelectSingleNode("rateObservationQuoteBasis");
     
     if (rateObservationQuoteBasisNode != null)
     {
         if (rateObservationQuoteBasisNode.Attributes["href"] != null || rateObservationQuoteBasisNode.Attributes["id"] != null) 
         {
             if (rateObservationQuoteBasisNode.Attributes["id"] != null) 
             {
                 rateObservationQuoteBasisIDRef_ = rateObservationQuoteBasisNode.Attributes["id"].Value;
                 StrikeQuoteBasisEnum ob = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
                 IDManager.SetID(rateObservationQuoteBasisIDRef_, ob);
             }
             else if (rateObservationQuoteBasisNode.Attributes["href"] != null)
             {
                 rateObservationQuoteBasisIDRef_ = rateObservationQuoteBasisNode.Attributes["href"].Value;
             }
             else
             {
                 rateObservationQuoteBasis_ = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
             }
         }
         else
         {
             rateObservationQuoteBasis_ = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
         }
     }
     
 
     XmlNode payoutFormulaNode = xmlNode.SelectSingleNode("payoutFormula");
     
     if (payoutFormulaNode != null)
     {
         if (payoutFormulaNode.Attributes["href"] != null || payoutFormulaNode.Attributes["id"] != null) 
         {
             if (payoutFormulaNode.Attributes["id"] != null) 
             {
                 payoutFormulaIDRef_ = payoutFormulaNode.Attributes["id"].Value;
                 XsdTypeString ob = new XsdTypeString(payoutFormulaNode);
                 IDManager.SetID(payoutFormulaIDRef_, ob);
             }
             else if (payoutFormulaNode.Attributes["href"] != null)
             {
                 payoutFormulaIDRef_ = payoutFormulaNode.Attributes["href"].Value;
             }
             else
             {
                 payoutFormula_ = new XsdTypeString(payoutFormulaNode);
             }
         }
         else
         {
             payoutFormula_ = new XsdTypeString(payoutFormulaNode);
         }
     }
     
 
     XmlNode precisionNode = xmlNode.SelectSingleNode("precision");
     
     if (precisionNode != null)
     {
         if (precisionNode.Attributes["href"] != null || precisionNode.Attributes["id"] != null) 
         {
             if (precisionNode.Attributes["id"] != null) 
             {
                 precisionIDRef_ = precisionNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(precisionNode);
                 IDManager.SetID(precisionIDRef_, ob);
             }
             else if (precisionNode.Attributes["href"] != null)
             {
                 precisionIDRef_ = precisionNode.Attributes["href"].Value;
             }
             else
             {
                 precision_ = new XsdTypeNonNegativeInteger(precisionNode);
             }
         }
         else
         {
             precision_ = new XsdTypeNonNegativeInteger(precisionNode);
         }
     }
     
 
 }
コード例 #19
0
        public FxAsianFeature(XmlNode xmlNode)
        {
            XmlNodeList primaryRateSourceNodeList = xmlNode.SelectNodes("primaryRateSource");

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

            foreach (XmlNode item in primaryRateSourceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        primaryRateSourceIDRef = item.Attributes["id"].Name;
                        InformationSource ob = InformationSource();
                        IDManager.SetID(primaryRateSourceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        primaryRateSourceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        primaryRateSource = new InformationSource(item);
                    }
                }
            }


            XmlNodeList secondaryRateSourceNodeList = xmlNode.SelectNodes("secondaryRateSource");

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

            foreach (XmlNode item in secondaryRateSourceNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        secondaryRateSourceIDRef = item.Attributes["id"].Name;
                        InformationSource ob = InformationSource();
                        IDManager.SetID(secondaryRateSourceIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        secondaryRateSourceIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        secondaryRateSource = new InformationSource(item);
                    }
                }
            }


            XmlNodeList fixingTimeNodeList = xmlNode.SelectNodes("fixingTime");

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

            foreach (XmlNode item in fixingTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        fixingTimeIDRef = item.Attributes["id"].Name;
                        BusinessCenterTime ob = BusinessCenterTime();
                        IDManager.SetID(fixingTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        fixingTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        fixingTime = new BusinessCenterTime(item);
                    }
                }
            }


            XmlNodeList observationScheduleNodeList = xmlNode.SelectNodes("observationSchedule");

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

            foreach (XmlNode item in observationScheduleNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        observationScheduleIDRef = item.Attributes["id"].Name;
                        FxAverageRateObservationSchedule ob = FxAverageRateObservationSchedule();
                        IDManager.SetID(observationScheduleIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        observationScheduleIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        observationSchedule = new FxAverageRateObservationSchedule(item);
                    }
                }
            }


            XmlNodeList rateObservationNodeList = xmlNode.SelectNodes("rateObservation");

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


            XmlNodeList rateObservationQuoteBasisNodeList = xmlNode.SelectNodes("rateObservationQuoteBasis");

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

            foreach (XmlNode item in rateObservationQuoteBasisNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        rateObservationQuoteBasisIDRef = item.Attributes["id"].Name;
                        StrikeQuoteBasisEnum ob = StrikeQuoteBasisEnum();
                        IDManager.SetID(rateObservationQuoteBasisIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        rateObservationQuoteBasisIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        rateObservationQuoteBasis = new StrikeQuoteBasisEnum(item);
                    }
                }
            }


            XmlNodeList payoutFormulaNodeList = xmlNode.SelectNodes("payoutFormula");

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

            foreach (XmlNode item in payoutFormulaNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        payoutFormulaIDRef = item.Attributes["id"].Name;
                        XsdTypeString ob = XsdTypeString();
                        IDManager.SetID(payoutFormulaIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        payoutFormulaIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        payoutFormula = new XsdTypeString(item);
                    }
                }
            }


            XmlNodeList precisionNodeList = xmlNode.SelectNodes("precision");

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

            foreach (XmlNode item in precisionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        precisionIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(precisionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        precisionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        precision = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #20
0
        public VersionedTradeId(XmlNode xmlNode)
        {
            XmlNodeList tradeIdNodeList = xmlNode.SelectNodes("tradeId");

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

            foreach (XmlNode item in tradeIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        tradeIdIDRef = item.Attributes["id"].Name;
                        TradeId ob = TradeId();
                        IDManager.SetID(tradeIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        tradeIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        tradeId = new TradeId(item);
                    }
                }
            }


            XmlNodeList versionNodeList = xmlNode.SelectNodes("version");

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

            foreach (XmlNode item in versionNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        versionIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(versionIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        versionIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        version = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList effectiveDateNodeList = xmlNode.SelectNodes("effectiveDate");

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

            foreach (XmlNode item in effectiveDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        effectiveDateIDRef = item.Attributes["id"].Name;
                        IdentifiedDate ob = IdentifiedDate();
                        IDManager.SetID(effectiveDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        effectiveDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        effectiveDate = new IdentifiedDate(item);
                    }
                }
            }
        }
コード例 #21
0
        public CashSettlementTerms(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");

            if (valuationDateNode != null)
            {
                if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null)
                {
                    if (valuationDateNode.Attributes["id"] != null)
                    {
                        valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                        ValuationDate ob = new ValuationDate(valuationDateNode);
                        IDManager.SetID(valuationDateIDRef_, ob);
                    }
                    else if (valuationDateNode.Attributes["href"] != null)
                    {
                        valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationDate_ = new ValuationDate(valuationDateNode);
                    }
                }
                else
                {
                    valuationDate_ = new ValuationDate(valuationDateNode);
                }
            }


            XmlNode valuationTimeNode = xmlNode.SelectSingleNode("valuationTime");

            if (valuationTimeNode != null)
            {
                if (valuationTimeNode.Attributes["href"] != null || valuationTimeNode.Attributes["id"] != null)
                {
                    if (valuationTimeNode.Attributes["id"] != null)
                    {
                        valuationTimeIDRef_ = valuationTimeNode.Attributes["id"].Value;
                        BusinessCenterTime ob = new BusinessCenterTime(valuationTimeNode);
                        IDManager.SetID(valuationTimeIDRef_, ob);
                    }
                    else if (valuationTimeNode.Attributes["href"] != null)
                    {
                        valuationTimeIDRef_ = valuationTimeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationTime_ = new BusinessCenterTime(valuationTimeNode);
                    }
                }
                else
                {
                    valuationTime_ = new BusinessCenterTime(valuationTimeNode);
                }
            }


            XmlNode quotationMethodNode = xmlNode.SelectSingleNode("quotationMethod");

            if (quotationMethodNode != null)
            {
                if (quotationMethodNode.Attributes["href"] != null || quotationMethodNode.Attributes["id"] != null)
                {
                    if (quotationMethodNode.Attributes["id"] != null)
                    {
                        quotationMethodIDRef_ = quotationMethodNode.Attributes["id"].Value;
                        QuotationRateTypeEnum ob = new QuotationRateTypeEnum(quotationMethodNode);
                        IDManager.SetID(quotationMethodIDRef_, ob);
                    }
                    else if (quotationMethodNode.Attributes["href"] != null)
                    {
                        quotationMethodIDRef_ = quotationMethodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        quotationMethod_ = new QuotationRateTypeEnum(quotationMethodNode);
                    }
                }
                else
                {
                    quotationMethod_ = new QuotationRateTypeEnum(quotationMethodNode);
                }
            }


            XmlNode quotationAmountNode = xmlNode.SelectSingleNode("quotationAmount");

            if (quotationAmountNode != null)
            {
                if (quotationAmountNode.Attributes["href"] != null || quotationAmountNode.Attributes["id"] != null)
                {
                    if (quotationAmountNode.Attributes["id"] != null)
                    {
                        quotationAmountIDRef_ = quotationAmountNode.Attributes["id"].Value;
                        Money ob = new Money(quotationAmountNode);
                        IDManager.SetID(quotationAmountIDRef_, ob);
                    }
                    else if (quotationAmountNode.Attributes["href"] != null)
                    {
                        quotationAmountIDRef_ = quotationAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        quotationAmount_ = new Money(quotationAmountNode);
                    }
                }
                else
                {
                    quotationAmount_ = new Money(quotationAmountNode);
                }
            }


            XmlNode minimumQuotationAmountNode = xmlNode.SelectSingleNode("minimumQuotationAmount");

            if (minimumQuotationAmountNode != null)
            {
                if (minimumQuotationAmountNode.Attributes["href"] != null || minimumQuotationAmountNode.Attributes["id"] != null)
                {
                    if (minimumQuotationAmountNode.Attributes["id"] != null)
                    {
                        minimumQuotationAmountIDRef_ = minimumQuotationAmountNode.Attributes["id"].Value;
                        Money ob = new Money(minimumQuotationAmountNode);
                        IDManager.SetID(minimumQuotationAmountIDRef_, ob);
                    }
                    else if (minimumQuotationAmountNode.Attributes["href"] != null)
                    {
                        minimumQuotationAmountIDRef_ = minimumQuotationAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        minimumQuotationAmount_ = new Money(minimumQuotationAmountNode);
                    }
                }
                else
                {
                    minimumQuotationAmount_ = new Money(minimumQuotationAmountNode);
                }
            }


            XmlNodeList dealerNodeList = xmlNode.SelectNodes("dealer");

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


            XmlNode cashSettlementBusinessDaysNode = xmlNode.SelectSingleNode("cashSettlementBusinessDays");

            if (cashSettlementBusinessDaysNode != null)
            {
                if (cashSettlementBusinessDaysNode.Attributes["href"] != null || cashSettlementBusinessDaysNode.Attributes["id"] != null)
                {
                    if (cashSettlementBusinessDaysNode.Attributes["id"] != null)
                    {
                        cashSettlementBusinessDaysIDRef_ = cashSettlementBusinessDaysNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
                        IDManager.SetID(cashSettlementBusinessDaysIDRef_, ob);
                    }
                    else if (cashSettlementBusinessDaysNode.Attributes["href"] != null)
                    {
                        cashSettlementBusinessDaysIDRef_ = cashSettlementBusinessDaysNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashSettlementBusinessDays_ = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
                    }
                }
                else
                {
                    cashSettlementBusinessDays_ = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
                }
            }


            XmlNode cashSettlementAmountNode = xmlNode.SelectSingleNode("cashSettlementAmount");

            if (cashSettlementAmountNode != null)
            {
                if (cashSettlementAmountNode.Attributes["href"] != null || cashSettlementAmountNode.Attributes["id"] != null)
                {
                    if (cashSettlementAmountNode.Attributes["id"] != null)
                    {
                        cashSettlementAmountIDRef_ = cashSettlementAmountNode.Attributes["id"].Value;
                        Money ob = new Money(cashSettlementAmountNode);
                        IDManager.SetID(cashSettlementAmountIDRef_, ob);
                    }
                    else if (cashSettlementAmountNode.Attributes["href"] != null)
                    {
                        cashSettlementAmountIDRef_ = cashSettlementAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashSettlementAmount_ = new Money(cashSettlementAmountNode);
                    }
                }
                else
                {
                    cashSettlementAmount_ = new Money(cashSettlementAmountNode);
                }
            }


            XmlNode recoveryFactorNode = xmlNode.SelectSingleNode("recoveryFactor");

            if (recoveryFactorNode != null)
            {
                if (recoveryFactorNode.Attributes["href"] != null || recoveryFactorNode.Attributes["id"] != null)
                {
                    if (recoveryFactorNode.Attributes["id"] != null)
                    {
                        recoveryFactorIDRef_ = recoveryFactorNode.Attributes["id"].Value;
                        RestrictedPercentage ob = new RestrictedPercentage(recoveryFactorNode);
                        IDManager.SetID(recoveryFactorIDRef_, ob);
                    }
                    else if (recoveryFactorNode.Attributes["href"] != null)
                    {
                        recoveryFactorIDRef_ = recoveryFactorNode.Attributes["href"].Value;
                    }
                    else
                    {
                        recoveryFactor_ = new RestrictedPercentage(recoveryFactorNode);
                    }
                }
                else
                {
                    recoveryFactor_ = new RestrictedPercentage(recoveryFactorNode);
                }
            }


            XmlNode fixedSettlementNode = xmlNode.SelectSingleNode("fixedSettlement");

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


            XmlNode accruedInterestNode = xmlNode.SelectSingleNode("accruedInterest");

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


            XmlNode valuationMethodNode = xmlNode.SelectSingleNode("valuationMethod");

            if (valuationMethodNode != null)
            {
                if (valuationMethodNode.Attributes["href"] != null || valuationMethodNode.Attributes["id"] != null)
                {
                    if (valuationMethodNode.Attributes["id"] != null)
                    {
                        valuationMethodIDRef_ = valuationMethodNode.Attributes["id"].Value;
                        ValuationMethodEnum ob = new ValuationMethodEnum(valuationMethodNode);
                        IDManager.SetID(valuationMethodIDRef_, ob);
                    }
                    else if (valuationMethodNode.Attributes["href"] != null)
                    {
                        valuationMethodIDRef_ = valuationMethodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationMethod_ = new ValuationMethodEnum(valuationMethodNode);
                    }
                }
                else
                {
                    valuationMethod_ = new ValuationMethodEnum(valuationMethodNode);
                }
            }
        }
コード例 #22
0
 public VersionedTradeId(XmlNode xmlNode)
 {
     XmlNode tradeIdNode = xmlNode.SelectSingleNode("tradeId");
     
     if (tradeIdNode != null)
     {
         if (tradeIdNode.Attributes["href"] != null || tradeIdNode.Attributes["id"] != null) 
         {
             if (tradeIdNode.Attributes["id"] != null) 
             {
                 tradeIdIDRef_ = tradeIdNode.Attributes["id"].Value;
                 TradeId ob = new TradeId(tradeIdNode);
                 IDManager.SetID(tradeIdIDRef_, ob);
             }
             else if (tradeIdNode.Attributes["href"] != null)
             {
                 tradeIdIDRef_ = tradeIdNode.Attributes["href"].Value;
             }
             else
             {
                 tradeId_ = new TradeId(tradeIdNode);
             }
         }
         else
         {
             tradeId_ = new TradeId(tradeIdNode);
         }
     }
     
 
     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;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(versionNode);
                 IDManager.SetID(versionIDRef_, ob);
             }
             else if (versionNode.Attributes["href"] != null)
             {
                 versionIDRef_ = versionNode.Attributes["href"].Value;
             }
             else
             {
                 version_ = new XsdTypeNonNegativeInteger(versionNode);
             }
         }
         else
         {
             version_ = new XsdTypeNonNegativeInteger(versionNode);
         }
     }
     
 
     XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");
     
     if (effectiveDateNode != null)
     {
         if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null) 
         {
             if (effectiveDateNode.Attributes["id"] != null) 
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                 IdentifiedDate ob = new IdentifiedDate(effectiveDateNode);
                 IDManager.SetID(effectiveDateIDRef_, ob);
             }
             else if (effectiveDateNode.Attributes["href"] != null)
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
             }
             else
             {
                 effectiveDate_ = new IdentifiedDate(effectiveDateNode);
             }
         }
         else
         {
             effectiveDate_ = new IdentifiedDate(effectiveDateNode);
         }
     }
     
 
 }
コード例 #23
0
        public FxAsianFeature(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 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);
                }
            }


            XmlNode observationScheduleNode = xmlNode.SelectSingleNode("observationSchedule");

            if (observationScheduleNode != null)
            {
                if (observationScheduleNode.Attributes["href"] != null || observationScheduleNode.Attributes["id"] != null)
                {
                    if (observationScheduleNode.Attributes["id"] != null)
                    {
                        observationScheduleIDRef_ = observationScheduleNode.Attributes["id"].Value;
                        FxAverageRateObservationSchedule ob = new FxAverageRateObservationSchedule(observationScheduleNode);
                        IDManager.SetID(observationScheduleIDRef_, ob);
                    }
                    else if (observationScheduleNode.Attributes["href"] != null)
                    {
                        observationScheduleIDRef_ = observationScheduleNode.Attributes["href"].Value;
                    }
                    else
                    {
                        observationSchedule_ = new FxAverageRateObservationSchedule(observationScheduleNode);
                    }
                }
                else
                {
                    observationSchedule_ = new FxAverageRateObservationSchedule(observationScheduleNode);
                }
            }


            XmlNodeList rateObservationNodeList = xmlNode.SelectNodes("rateObservation");

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


            XmlNode rateObservationQuoteBasisNode = xmlNode.SelectSingleNode("rateObservationQuoteBasis");

            if (rateObservationQuoteBasisNode != null)
            {
                if (rateObservationQuoteBasisNode.Attributes["href"] != null || rateObservationQuoteBasisNode.Attributes["id"] != null)
                {
                    if (rateObservationQuoteBasisNode.Attributes["id"] != null)
                    {
                        rateObservationQuoteBasisIDRef_ = rateObservationQuoteBasisNode.Attributes["id"].Value;
                        StrikeQuoteBasisEnum ob = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
                        IDManager.SetID(rateObservationQuoteBasisIDRef_, ob);
                    }
                    else if (rateObservationQuoteBasisNode.Attributes["href"] != null)
                    {
                        rateObservationQuoteBasisIDRef_ = rateObservationQuoteBasisNode.Attributes["href"].Value;
                    }
                    else
                    {
                        rateObservationQuoteBasis_ = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
                    }
                }
                else
                {
                    rateObservationQuoteBasis_ = new StrikeQuoteBasisEnum(rateObservationQuoteBasisNode);
                }
            }


            XmlNode payoutFormulaNode = xmlNode.SelectSingleNode("payoutFormula");

            if (payoutFormulaNode != null)
            {
                if (payoutFormulaNode.Attributes["href"] != null || payoutFormulaNode.Attributes["id"] != null)
                {
                    if (payoutFormulaNode.Attributes["id"] != null)
                    {
                        payoutFormulaIDRef_ = payoutFormulaNode.Attributes["id"].Value;
                        XsdTypeString ob = new XsdTypeString(payoutFormulaNode);
                        IDManager.SetID(payoutFormulaIDRef_, ob);
                    }
                    else if (payoutFormulaNode.Attributes["href"] != null)
                    {
                        payoutFormulaIDRef_ = payoutFormulaNode.Attributes["href"].Value;
                    }
                    else
                    {
                        payoutFormula_ = new XsdTypeString(payoutFormulaNode);
                    }
                }
                else
                {
                    payoutFormula_ = new XsdTypeString(payoutFormulaNode);
                }
            }


            XmlNode precisionNode = xmlNode.SelectSingleNode("precision");

            if (precisionNode != null)
            {
                if (precisionNode.Attributes["href"] != null || precisionNode.Attributes["id"] != null)
                {
                    if (precisionNode.Attributes["id"] != null)
                    {
                        precisionIDRef_ = precisionNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(precisionNode);
                        IDManager.SetID(precisionIDRef_, ob);
                    }
                    else if (precisionNode.Attributes["href"] != null)
                    {
                        precisionIDRef_ = precisionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        precision_ = new XsdTypeNonNegativeInteger(precisionNode);
                    }
                }
                else
                {
                    precision_ = new XsdTypeNonNegativeInteger(precisionNode);
                }
            }
        }
コード例 #24
0
        public CashSettlementTerms(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList valuationDateNodeList = xmlNode.SelectNodes("valuationDate");

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

            foreach (XmlNode item in valuationDateNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationDateIDRef = item.Attributes["id"].Name;
                        ValuationDate ob = ValuationDate();
                        IDManager.SetID(valuationDateIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationDateIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationDate = new ValuationDate(item);
                    }
                }
            }


            XmlNodeList valuationTimeNodeList = xmlNode.SelectNodes("valuationTime");

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

            foreach (XmlNode item in valuationTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationTimeIDRef = item.Attributes["id"].Name;
                        BusinessCenterTime ob = BusinessCenterTime();
                        IDManager.SetID(valuationTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationTime = new BusinessCenterTime(item);
                    }
                }
            }


            XmlNodeList quotationMethodNodeList = xmlNode.SelectNodes("quotationMethod");

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

            foreach (XmlNode item in quotationMethodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        quotationMethodIDRef = item.Attributes["id"].Name;
                        QuotationRateTypeEnum ob = QuotationRateTypeEnum();
                        IDManager.SetID(quotationMethodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        quotationMethodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        quotationMethod = new QuotationRateTypeEnum(item);
                    }
                }
            }


            XmlNodeList quotationAmountNodeList = xmlNode.SelectNodes("quotationAmount");

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

            foreach (XmlNode item in quotationAmountNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        quotationAmountIDRef = item.Attributes["id"].Name;
                        Money ob = Money();
                        IDManager.SetID(quotationAmountIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        quotationAmountIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        quotationAmount = new Money(item);
                    }
                }
            }


            XmlNodeList minimumQuotationAmountNodeList = xmlNode.SelectNodes("minimumQuotationAmount");

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

            foreach (XmlNode item in minimumQuotationAmountNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        minimumQuotationAmountIDRef = item.Attributes["id"].Name;
                        Money ob = Money();
                        IDManager.SetID(minimumQuotationAmountIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        minimumQuotationAmountIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        minimumQuotationAmount = new Money(item);
                    }
                }
            }


            XmlNodeList dealerNodeList = xmlNode.SelectNodes("dealer");

            foreach (XmlNode item in dealerNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        dealerIDRef = item.Attributes["id"].Name;
                        XsdTypeString ob = new XsdTypeString();
                        ob.Add(new XsdTypeString(item));
                        IDManager.SetID(dealerIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        dealerIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        dealer.Add(new XsdTypeString(item));
                    }
                }
            }


            XmlNodeList cashSettlementBusinessDaysNodeList = xmlNode.SelectNodes("cashSettlementBusinessDays");

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

            foreach (XmlNode item in cashSettlementBusinessDaysNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashSettlementBusinessDaysIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(cashSettlementBusinessDaysIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashSettlementBusinessDaysIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashSettlementBusinessDays = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }


            XmlNodeList cashSettlementAmountNodeList = xmlNode.SelectNodes("cashSettlementAmount");

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

            foreach (XmlNode item in cashSettlementAmountNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashSettlementAmountIDRef = item.Attributes["id"].Name;
                        Money ob = Money();
                        IDManager.SetID(cashSettlementAmountIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashSettlementAmountIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashSettlementAmount = new Money(item);
                    }
                }
            }


            XmlNodeList recoveryFactorNodeList = xmlNode.SelectNodes("recoveryFactor");

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

            foreach (XmlNode item in recoveryFactorNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        recoveryFactorIDRef = item.Attributes["id"].Name;
                        RestrictedPercentage ob = RestrictedPercentage();
                        IDManager.SetID(recoveryFactorIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        recoveryFactorIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        recoveryFactor = new RestrictedPercentage(item);
                    }
                }
            }


            XmlNodeList fixedSettlementNodeList = xmlNode.SelectNodes("fixedSettlement");

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

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


            XmlNodeList accruedInterestNodeList = xmlNode.SelectNodes("accruedInterest");

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

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


            XmlNodeList valuationMethodNodeList = xmlNode.SelectNodes("valuationMethod");

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

            foreach (XmlNode item in valuationMethodNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valuationMethodIDRef = item.Attributes["id"].Name;
                        ValuationMethodEnum ob = ValuationMethodEnum();
                        IDManager.SetID(valuationMethodIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valuationMethodIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        valuationMethod = new ValuationMethodEnum(item);
                    }
                }
            }
        }
 public PhysicalSettlementPeriod(XmlNode xmlNode)
 {
     XmlNode businessDaysNotSpecifiedNode = xmlNode.SelectSingleNode("businessDaysNotSpecified");
     
     if (businessDaysNotSpecifiedNode != null)
     {
         if (businessDaysNotSpecifiedNode.Attributes["href"] != null || businessDaysNotSpecifiedNode.Attributes["id"] != null) 
         {
             if (businessDaysNotSpecifiedNode.Attributes["id"] != null) 
             {
                 businessDaysNotSpecifiedIDRef_ = businessDaysNotSpecifiedNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(businessDaysNotSpecifiedNode);
                 IDManager.SetID(businessDaysNotSpecifiedIDRef_, ob);
             }
             else if (businessDaysNotSpecifiedNode.Attributes["href"] != null)
             {
                 businessDaysNotSpecifiedIDRef_ = businessDaysNotSpecifiedNode.Attributes["href"].Value;
             }
             else
             {
                 businessDaysNotSpecified_ = new XsdTypeBoolean(businessDaysNotSpecifiedNode);
             }
         }
         else
         {
             businessDaysNotSpecified_ = new XsdTypeBoolean(businessDaysNotSpecifiedNode);
         }
     }
     
 
     XmlNode businessDaysNode = xmlNode.SelectSingleNode("businessDays");
     
     if (businessDaysNode != null)
     {
         if (businessDaysNode.Attributes["href"] != null || businessDaysNode.Attributes["id"] != null) 
         {
             if (businessDaysNode.Attributes["id"] != null) 
             {
                 businessDaysIDRef_ = businessDaysNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(businessDaysNode);
                 IDManager.SetID(businessDaysIDRef_, ob);
             }
             else if (businessDaysNode.Attributes["href"] != null)
             {
                 businessDaysIDRef_ = businessDaysNode.Attributes["href"].Value;
             }
             else
             {
                 businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
             }
         }
         else
         {
             businessDays_ = new XsdTypeNonNegativeInteger(businessDaysNode);
         }
     }
     
 
     XmlNode maximumBusinessDaysNode = xmlNode.SelectSingleNode("maximumBusinessDays");
     
     if (maximumBusinessDaysNode != null)
     {
         if (maximumBusinessDaysNode.Attributes["href"] != null || maximumBusinessDaysNode.Attributes["id"] != null) 
         {
             if (maximumBusinessDaysNode.Attributes["id"] != null) 
             {
                 maximumBusinessDaysIDRef_ = maximumBusinessDaysNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
                 IDManager.SetID(maximumBusinessDaysIDRef_, ob);
             }
             else if (maximumBusinessDaysNode.Attributes["href"] != null)
             {
                 maximumBusinessDaysIDRef_ = maximumBusinessDaysNode.Attributes["href"].Value;
             }
             else
             {
                 maximumBusinessDays_ = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
             }
         }
         else
         {
             maximumBusinessDays_ = new XsdTypeNonNegativeInteger(maximumBusinessDaysNode);
         }
     }
     
 
 }
コード例 #26
0
        public AssetPool(XmlNode xmlNode)
        {
            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;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(versionNode);
                        IDManager.SetID(versionIDRef_, ob);
                    }
                    else if (versionNode.Attributes["href"] != null)
                    {
                        versionIDRef_ = versionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        version_ = new XsdTypeNonNegativeInteger(versionNode);
                    }
                }
                else
                {
                    version_ = new XsdTypeNonNegativeInteger(versionNode);
                }
            }


            XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");

            if (effectiveDateNode != null)
            {
                if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null)
                {
                    if (effectiveDateNode.Attributes["id"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                        IdentifiedDate ob = new IdentifiedDate(effectiveDateNode);
                        IDManager.SetID(effectiveDateIDRef_, ob);
                    }
                    else if (effectiveDateNode.Attributes["href"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                    }
                }
                else
                {
                    effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                }
            }


            XmlNode initialFactorNode = xmlNode.SelectSingleNode("initialFactor");

            if (initialFactorNode != null)
            {
                if (initialFactorNode.Attributes["href"] != null || initialFactorNode.Attributes["id"] != null)
                {
                    if (initialFactorNode.Attributes["id"] != null)
                    {
                        initialFactorIDRef_ = initialFactorNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(initialFactorNode);
                        IDManager.SetID(initialFactorIDRef_, ob);
                    }
                    else if (initialFactorNode.Attributes["href"] != null)
                    {
                        initialFactorIDRef_ = initialFactorNode.Attributes["href"].Value;
                    }
                    else
                    {
                        initialFactor_ = new XsdTypeDecimal(initialFactorNode);
                    }
                }
                else
                {
                    initialFactor_ = new XsdTypeDecimal(initialFactorNode);
                }
            }


            XmlNode currentFactorNode = xmlNode.SelectSingleNode("currentFactor");

            if (currentFactorNode != null)
            {
                if (currentFactorNode.Attributes["href"] != null || currentFactorNode.Attributes["id"] != null)
                {
                    if (currentFactorNode.Attributes["id"] != null)
                    {
                        currentFactorIDRef_ = currentFactorNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(currentFactorNode);
                        IDManager.SetID(currentFactorIDRef_, ob);
                    }
                    else if (currentFactorNode.Attributes["href"] != null)
                    {
                        currentFactorIDRef_ = currentFactorNode.Attributes["href"].Value;
                    }
                    else
                    {
                        currentFactor_ = new XsdTypeDecimal(currentFactorNode);
                    }
                }
                else
                {
                    currentFactor_ = new XsdTypeDecimal(currentFactorNode);
                }
            }
        }
コード例 #27
0
 public AssetPool(XmlNode xmlNode)
 {
     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;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(versionNode);
                 IDManager.SetID(versionIDRef_, ob);
             }
             else if (versionNode.Attributes["href"] != null)
             {
                 versionIDRef_ = versionNode.Attributes["href"].Value;
             }
             else
             {
                 version_ = new XsdTypeNonNegativeInteger(versionNode);
             }
         }
         else
         {
             version_ = new XsdTypeNonNegativeInteger(versionNode);
         }
     }
     
 
     XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");
     
     if (effectiveDateNode != null)
     {
         if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null) 
         {
             if (effectiveDateNode.Attributes["id"] != null) 
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                 IdentifiedDate ob = new IdentifiedDate(effectiveDateNode);
                 IDManager.SetID(effectiveDateIDRef_, ob);
             }
             else if (effectiveDateNode.Attributes["href"] != null)
             {
                 effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
             }
             else
             {
                 effectiveDate_ = new IdentifiedDate(effectiveDateNode);
             }
         }
         else
         {
             effectiveDate_ = new IdentifiedDate(effectiveDateNode);
         }
     }
     
 
     XmlNode initialFactorNode = xmlNode.SelectSingleNode("initialFactor");
     
     if (initialFactorNode != null)
     {
         if (initialFactorNode.Attributes["href"] != null || initialFactorNode.Attributes["id"] != null) 
         {
             if (initialFactorNode.Attributes["id"] != null) 
             {
                 initialFactorIDRef_ = initialFactorNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(initialFactorNode);
                 IDManager.SetID(initialFactorIDRef_, ob);
             }
             else if (initialFactorNode.Attributes["href"] != null)
             {
                 initialFactorIDRef_ = initialFactorNode.Attributes["href"].Value;
             }
             else
             {
                 initialFactor_ = new XsdTypeDecimal(initialFactorNode);
             }
         }
         else
         {
             initialFactor_ = new XsdTypeDecimal(initialFactorNode);
         }
     }
     
 
     XmlNode currentFactorNode = xmlNode.SelectSingleNode("currentFactor");
     
     if (currentFactorNode != null)
     {
         if (currentFactorNode.Attributes["href"] != null || currentFactorNode.Attributes["id"] != null) 
         {
             if (currentFactorNode.Attributes["id"] != null) 
             {
                 currentFactorIDRef_ = currentFactorNode.Attributes["id"].Value;
                 XsdTypeDecimal ob = new XsdTypeDecimal(currentFactorNode);
                 IDManager.SetID(currentFactorIDRef_, ob);
             }
             else if (currentFactorNode.Attributes["href"] != null)
             {
                 currentFactorIDRef_ = currentFactorNode.Attributes["href"].Value;
             }
             else
             {
                 currentFactor_ = new XsdTypeDecimal(currentFactorNode);
             }
         }
         else
         {
             currentFactor_ = new XsdTypeDecimal(currentFactorNode);
         }
     }
     
 
 }
コード例 #28
0
        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);
                }
            }
        }
コード例 #29
0
        public EquityValuation(XmlNode xmlNode)
        {
            XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");

            if (valuationDateNode != null)
            {
                if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null)
                {
                    if (valuationDateNode.Attributes["id"] != null)
                    {
                        valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                        AdjustableDateOrRelativeDateSequence ob = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
                        IDManager.SetID(valuationDateIDRef_, ob);
                    }
                    else if (valuationDateNode.Attributes["href"] != null)
                    {
                        valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationDate_ = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
                    }
                }
                else
                {
                    valuationDate_ = new AdjustableDateOrRelativeDateSequence(valuationDateNode);
                }
            }


            XmlNode valuationDatesNode = xmlNode.SelectSingleNode("valuationDates");

            if (valuationDatesNode != null)
            {
                if (valuationDatesNode.Attributes["href"] != null || valuationDatesNode.Attributes["id"] != null)
                {
                    if (valuationDatesNode.Attributes["id"] != null)
                    {
                        valuationDatesIDRef_ = valuationDatesNode.Attributes["id"].Value;
                        AdjustableRelativeOrPeriodicDates ob = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
                        IDManager.SetID(valuationDatesIDRef_, ob);
                    }
                    else if (valuationDatesNode.Attributes["href"] != null)
                    {
                        valuationDatesIDRef_ = valuationDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationDates_ = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
                    }
                }
                else
                {
                    valuationDates_ = new AdjustableRelativeOrPeriodicDates(valuationDatesNode);
                }
            }


            XmlNode valuationTimeTypeNode = xmlNode.SelectSingleNode("valuationTimeType");

            if (valuationTimeTypeNode != null)
            {
                if (valuationTimeTypeNode.Attributes["href"] != null || valuationTimeTypeNode.Attributes["id"] != null)
                {
                    if (valuationTimeTypeNode.Attributes["id"] != null)
                    {
                        valuationTimeTypeIDRef_ = valuationTimeTypeNode.Attributes["id"].Value;
                        TimeTypeEnum ob = new TimeTypeEnum(valuationTimeTypeNode);
                        IDManager.SetID(valuationTimeTypeIDRef_, ob);
                    }
                    else if (valuationTimeTypeNode.Attributes["href"] != null)
                    {
                        valuationTimeTypeIDRef_ = valuationTimeTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationTimeType_ = new TimeTypeEnum(valuationTimeTypeNode);
                    }
                }
                else
                {
                    valuationTimeType_ = new TimeTypeEnum(valuationTimeTypeNode);
                }
            }


            XmlNode valuationTimeNode = xmlNode.SelectSingleNode("valuationTime");

            if (valuationTimeNode != null)
            {
                if (valuationTimeNode.Attributes["href"] != null || valuationTimeNode.Attributes["id"] != null)
                {
                    if (valuationTimeNode.Attributes["id"] != null)
                    {
                        valuationTimeIDRef_ = valuationTimeNode.Attributes["id"].Value;
                        BusinessCenterTime ob = new BusinessCenterTime(valuationTimeNode);
                        IDManager.SetID(valuationTimeIDRef_, ob);
                    }
                    else if (valuationTimeNode.Attributes["href"] != null)
                    {
                        valuationTimeIDRef_ = valuationTimeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        valuationTime_ = new BusinessCenterTime(valuationTimeNode);
                    }
                }
                else
                {
                    valuationTime_ = new BusinessCenterTime(valuationTimeNode);
                }
            }


            XmlNode futuresPriceValuationNode = xmlNode.SelectSingleNode("futuresPriceValuation");

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


            XmlNode optionsPriceValuationNode = xmlNode.SelectSingleNode("optionsPriceValuation");

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


            XmlNode numberOfValuationDatesNode = xmlNode.SelectSingleNode("numberOfValuationDates");

            if (numberOfValuationDatesNode != null)
            {
                if (numberOfValuationDatesNode.Attributes["href"] != null || numberOfValuationDatesNode.Attributes["id"] != null)
                {
                    if (numberOfValuationDatesNode.Attributes["id"] != null)
                    {
                        numberOfValuationDatesIDRef_ = numberOfValuationDatesNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
                        IDManager.SetID(numberOfValuationDatesIDRef_, ob);
                    }
                    else if (numberOfValuationDatesNode.Attributes["href"] != null)
                    {
                        numberOfValuationDatesIDRef_ = numberOfValuationDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        numberOfValuationDates_ = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
                    }
                }
                else
                {
                    numberOfValuationDates_ = new XsdTypeNonNegativeInteger(numberOfValuationDatesNode);
                }
            }


            XmlNode dividendValuationDatesNode = xmlNode.SelectSingleNode("dividendValuationDates");

            if (dividendValuationDatesNode != null)
            {
                if (dividendValuationDatesNode.Attributes["href"] != null || dividendValuationDatesNode.Attributes["id"] != null)
                {
                    if (dividendValuationDatesNode.Attributes["id"] != null)
                    {
                        dividendValuationDatesIDRef_ = dividendValuationDatesNode.Attributes["id"].Value;
                        AdjustableRelativeOrPeriodicDates ob = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
                        IDManager.SetID(dividendValuationDatesIDRef_, ob);
                    }
                    else if (dividendValuationDatesNode.Attributes["href"] != null)
                    {
                        dividendValuationDatesIDRef_ = dividendValuationDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        dividendValuationDates_ = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
                    }
                }
                else
                {
                    dividendValuationDates_ = new AdjustableRelativeOrPeriodicDates(dividendValuationDatesNode);
                }
            }


            XmlNode fPVFinalPriceElectionFallbackNode = xmlNode.SelectSingleNode("fPVFinalPriceElectionFallback");

            if (fPVFinalPriceElectionFallbackNode != null)
            {
                if (fPVFinalPriceElectionFallbackNode.Attributes["href"] != null || fPVFinalPriceElectionFallbackNode.Attributes["id"] != null)
                {
                    if (fPVFinalPriceElectionFallbackNode.Attributes["id"] != null)
                    {
                        fPVFinalPriceElectionFallbackIDRef_ = fPVFinalPriceElectionFallbackNode.Attributes["id"].Value;
                        FPVFinalPriceElectionFallbackEnum ob = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
                        IDManager.SetID(fPVFinalPriceElectionFallbackIDRef_, ob);
                    }
                    else if (fPVFinalPriceElectionFallbackNode.Attributes["href"] != null)
                    {
                        fPVFinalPriceElectionFallbackIDRef_ = fPVFinalPriceElectionFallbackNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fPVFinalPriceElectionFallback_ = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
                    }
                }
                else
                {
                    fPVFinalPriceElectionFallback_ = new FPVFinalPriceElectionFallbackEnum(fPVFinalPriceElectionFallbackNode);
                }
            }
        }
コード例 #30
0
        public PartialExercise(XmlNode xmlNode)
        {
            XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");

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


            XmlNodeList integralMultipleAmountNodeList = xmlNode.SelectNodes("integralMultipleAmount");

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

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


            XmlNodeList minimumNotionalAmountNodeList = xmlNode.SelectNodes("minimumNotionalAmount");

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

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


            XmlNodeList minimumNumberOfOptionsNodeList = xmlNode.SelectNodes("minimumNumberOfOptions");

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

            foreach (XmlNode item in minimumNumberOfOptionsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        minimumNumberOfOptionsIDRef = item.Attributes["id"].Name;
                        XsdTypeNonNegativeInteger ob = XsdTypeNonNegativeInteger();
                        IDManager.SetID(minimumNumberOfOptionsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        minimumNumberOfOptionsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        minimumNumberOfOptions = new XsdTypeNonNegativeInteger(item);
                    }
                }
            }
        }
コード例 #31
0
        public LegIdentifier(XmlNode xmlNode)
        {
            XmlNode legIdNode = xmlNode.SelectSingleNode("legId");

            if (legIdNode != null)
            {
                if (legIdNode.Attributes["href"] != null || legIdNode.Attributes["id"] != null)
                {
                    if (legIdNode.Attributes["id"] != null)
                    {
                        legIdIDRef_ = legIdNode.Attributes["id"].Value;
                        LegId ob = new LegId(legIdNode);
                        IDManager.SetID(legIdIDRef_, ob);
                    }
                    else if (legIdNode.Attributes["href"] != null)
                    {
                        legIdIDRef_ = legIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        legId_ = new LegId(legIdNode);
                    }
                }
                else
                {
                    legId_ = new LegId(legIdNode);
                }
            }


            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;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(versionNode);
                        IDManager.SetID(versionIDRef_, ob);
                    }
                    else if (versionNode.Attributes["href"] != null)
                    {
                        versionIDRef_ = versionNode.Attributes["href"].Value;
                    }
                    else
                    {
                        version_ = new XsdTypeNonNegativeInteger(versionNode);
                    }
                }
                else
                {
                    version_ = new XsdTypeNonNegativeInteger(versionNode);
                }
            }


            XmlNode effectiveDateNode = xmlNode.SelectSingleNode("effectiveDate");

            if (effectiveDateNode != null)
            {
                if (effectiveDateNode.Attributes["href"] != null || effectiveDateNode.Attributes["id"] != null)
                {
                    if (effectiveDateNode.Attributes["id"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["id"].Value;
                        IdentifiedDate ob = new IdentifiedDate(effectiveDateNode);
                        IDManager.SetID(effectiveDateIDRef_, ob);
                    }
                    else if (effectiveDateNode.Attributes["href"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                    }
                }
                else
                {
                    effectiveDate_ = new IdentifiedDate(effectiveDateNode);
                }
            }
        }
 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);
         }
     }
     
 
 }
コード例 #33
0
        public MultipleExercise(XmlNode xmlNode)
        {
            XmlNodeList notionalReferenceNodeList = xmlNode.SelectNodes("notionalReference");

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


            XmlNode integralMultipleAmountNode = xmlNode.SelectSingleNode("integralMultipleAmount");

            if (integralMultipleAmountNode != null)
            {
                if (integralMultipleAmountNode.Attributes["href"] != null || integralMultipleAmountNode.Attributes["id"] != null)
                {
                    if (integralMultipleAmountNode.Attributes["id"] != null)
                    {
                        integralMultipleAmountIDRef_ = integralMultipleAmountNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(integralMultipleAmountNode);
                        IDManager.SetID(integralMultipleAmountIDRef_, ob);
                    }
                    else if (integralMultipleAmountNode.Attributes["href"] != null)
                    {
                        integralMultipleAmountIDRef_ = integralMultipleAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        integralMultipleAmount_ = new XsdTypeDecimal(integralMultipleAmountNode);
                    }
                }
                else
                {
                    integralMultipleAmount_ = new XsdTypeDecimal(integralMultipleAmountNode);
                }
            }


            XmlNode minimumNotionalAmountNode = xmlNode.SelectSingleNode("minimumNotionalAmount");

            if (minimumNotionalAmountNode != null)
            {
                if (minimumNotionalAmountNode.Attributes["href"] != null || minimumNotionalAmountNode.Attributes["id"] != null)
                {
                    if (minimumNotionalAmountNode.Attributes["id"] != null)
                    {
                        minimumNotionalAmountIDRef_ = minimumNotionalAmountNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(minimumNotionalAmountNode);
                        IDManager.SetID(minimumNotionalAmountIDRef_, ob);
                    }
                    else if (minimumNotionalAmountNode.Attributes["href"] != null)
                    {
                        minimumNotionalAmountIDRef_ = minimumNotionalAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        minimumNotionalAmount_ = new XsdTypeDecimal(minimumNotionalAmountNode);
                    }
                }
                else
                {
                    minimumNotionalAmount_ = new XsdTypeDecimal(minimumNotionalAmountNode);
                }
            }


            XmlNode minimumNumberOfOptionsNode = xmlNode.SelectSingleNode("minimumNumberOfOptions");

            if (minimumNumberOfOptionsNode != null)
            {
                if (minimumNumberOfOptionsNode.Attributes["href"] != null || minimumNumberOfOptionsNode.Attributes["id"] != null)
                {
                    if (minimumNumberOfOptionsNode.Attributes["id"] != null)
                    {
                        minimumNumberOfOptionsIDRef_ = minimumNumberOfOptionsNode.Attributes["id"].Value;
                        XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
                        IDManager.SetID(minimumNumberOfOptionsIDRef_, ob);
                    }
                    else if (minimumNumberOfOptionsNode.Attributes["href"] != null)
                    {
                        minimumNumberOfOptionsIDRef_ = minimumNumberOfOptionsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        minimumNumberOfOptions_ = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
                    }
                }
                else
                {
                    minimumNumberOfOptions_ = new XsdTypeNonNegativeInteger(minimumNumberOfOptionsNode);
                }
            }


            XmlNode maximumNotionalAmountNode = xmlNode.SelectSingleNode("maximumNotionalAmount");

            if (maximumNotionalAmountNode != null)
            {
                if (maximumNotionalAmountNode.Attributes["href"] != null || maximumNotionalAmountNode.Attributes["id"] != null)
                {
                    if (maximumNotionalAmountNode.Attributes["id"] != null)
                    {
                        maximumNotionalAmountIDRef_ = maximumNotionalAmountNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(maximumNotionalAmountNode);
                        IDManager.SetID(maximumNotionalAmountIDRef_, ob);
                    }
                    else if (maximumNotionalAmountNode.Attributes["href"] != null)
                    {
                        maximumNotionalAmountIDRef_ = maximumNotionalAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumNotionalAmount_ = new XsdTypeDecimal(maximumNotionalAmountNode);
                    }
                }
                else
                {
                    maximumNotionalAmount_ = new XsdTypeDecimal(maximumNotionalAmountNode);
                }
            }


            XmlNode maximumNumberOfOptionsNode = xmlNode.SelectSingleNode("maximumNumberOfOptions");

            if (maximumNumberOfOptionsNode != null)
            {
                if (maximumNumberOfOptionsNode.Attributes["href"] != null || maximumNumberOfOptionsNode.Attributes["id"] != null)
                {
                    if (maximumNumberOfOptionsNode.Attributes["id"] != null)
                    {
                        maximumNumberOfOptionsIDRef_ = maximumNumberOfOptionsNode.Attributes["id"].Value;
                        NonNegativeDecimal ob = new NonNegativeDecimal(maximumNumberOfOptionsNode);
                        IDManager.SetID(maximumNumberOfOptionsIDRef_, ob);
                    }
                    else if (maximumNumberOfOptionsNode.Attributes["href"] != null)
                    {
                        maximumNumberOfOptionsIDRef_ = maximumNumberOfOptionsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumNumberOfOptions_ = new NonNegativeDecimal(maximumNumberOfOptionsNode);
                    }
                }
                else
                {
                    maximumNumberOfOptions_ = new NonNegativeDecimal(maximumNumberOfOptionsNode);
                }
            }
        }
コード例 #34
0
 public CashSettlementTerms(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");
     
     if (valuationDateNode != null)
     {
         if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null) 
         {
             if (valuationDateNode.Attributes["id"] != null) 
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                 ValuationDate ob = new ValuationDate(valuationDateNode);
                 IDManager.SetID(valuationDateIDRef_, ob);
             }
             else if (valuationDateNode.Attributes["href"] != null)
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
             }
             else
             {
                 valuationDate_ = new ValuationDate(valuationDateNode);
             }
         }
         else
         {
             valuationDate_ = new ValuationDate(valuationDateNode);
         }
     }
     
 
     XmlNode valuationTimeNode = xmlNode.SelectSingleNode("valuationTime");
     
     if (valuationTimeNode != null)
     {
         if (valuationTimeNode.Attributes["href"] != null || valuationTimeNode.Attributes["id"] != null) 
         {
             if (valuationTimeNode.Attributes["id"] != null) 
             {
                 valuationTimeIDRef_ = valuationTimeNode.Attributes["id"].Value;
                 BusinessCenterTime ob = new BusinessCenterTime(valuationTimeNode);
                 IDManager.SetID(valuationTimeIDRef_, ob);
             }
             else if (valuationTimeNode.Attributes["href"] != null)
             {
                 valuationTimeIDRef_ = valuationTimeNode.Attributes["href"].Value;
             }
             else
             {
                 valuationTime_ = new BusinessCenterTime(valuationTimeNode);
             }
         }
         else
         {
             valuationTime_ = new BusinessCenterTime(valuationTimeNode);
         }
     }
     
 
     XmlNode quotationMethodNode = xmlNode.SelectSingleNode("quotationMethod");
     
     if (quotationMethodNode != null)
     {
         if (quotationMethodNode.Attributes["href"] != null || quotationMethodNode.Attributes["id"] != null) 
         {
             if (quotationMethodNode.Attributes["id"] != null) 
             {
                 quotationMethodIDRef_ = quotationMethodNode.Attributes["id"].Value;
                 QuotationRateTypeEnum ob = new QuotationRateTypeEnum(quotationMethodNode);
                 IDManager.SetID(quotationMethodIDRef_, ob);
             }
             else if (quotationMethodNode.Attributes["href"] != null)
             {
                 quotationMethodIDRef_ = quotationMethodNode.Attributes["href"].Value;
             }
             else
             {
                 quotationMethod_ = new QuotationRateTypeEnum(quotationMethodNode);
             }
         }
         else
         {
             quotationMethod_ = new QuotationRateTypeEnum(quotationMethodNode);
         }
     }
     
 
     XmlNode quotationAmountNode = xmlNode.SelectSingleNode("quotationAmount");
     
     if (quotationAmountNode != null)
     {
         if (quotationAmountNode.Attributes["href"] != null || quotationAmountNode.Attributes["id"] != null) 
         {
             if (quotationAmountNode.Attributes["id"] != null) 
             {
                 quotationAmountIDRef_ = quotationAmountNode.Attributes["id"].Value;
                 Money ob = new Money(quotationAmountNode);
                 IDManager.SetID(quotationAmountIDRef_, ob);
             }
             else if (quotationAmountNode.Attributes["href"] != null)
             {
                 quotationAmountIDRef_ = quotationAmountNode.Attributes["href"].Value;
             }
             else
             {
                 quotationAmount_ = new Money(quotationAmountNode);
             }
         }
         else
         {
             quotationAmount_ = new Money(quotationAmountNode);
         }
     }
     
 
     XmlNode minimumQuotationAmountNode = xmlNode.SelectSingleNode("minimumQuotationAmount");
     
     if (minimumQuotationAmountNode != null)
     {
         if (minimumQuotationAmountNode.Attributes["href"] != null || minimumQuotationAmountNode.Attributes["id"] != null) 
         {
             if (minimumQuotationAmountNode.Attributes["id"] != null) 
             {
                 minimumQuotationAmountIDRef_ = minimumQuotationAmountNode.Attributes["id"].Value;
                 Money ob = new Money(minimumQuotationAmountNode);
                 IDManager.SetID(minimumQuotationAmountIDRef_, ob);
             }
             else if (minimumQuotationAmountNode.Attributes["href"] != null)
             {
                 minimumQuotationAmountIDRef_ = minimumQuotationAmountNode.Attributes["href"].Value;
             }
             else
             {
                 minimumQuotationAmount_ = new Money(minimumQuotationAmountNode);
             }
         }
         else
         {
             minimumQuotationAmount_ = new Money(minimumQuotationAmountNode);
         }
     }
     
 
     XmlNodeList dealerNodeList = xmlNode.SelectNodes("dealer");
     
     if (dealerNodeList != null)
     {
         this.dealer_ = new List<XsdTypeString>();
         foreach (XmlNode item in dealerNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     dealerIDRef_ = item.Attributes["id"].Value;
                     dealer_.Add(new XsdTypeString(item));
                     IDManager.SetID(dealerIDRef_, dealer_[dealer_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     dealerIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 dealer_.Add(new XsdTypeString(item));
                 }
             }
             else
             {
                 dealer_.Add(new XsdTypeString(item));
             }
         }
     }
     
 
     XmlNode cashSettlementBusinessDaysNode = xmlNode.SelectSingleNode("cashSettlementBusinessDays");
     
     if (cashSettlementBusinessDaysNode != null)
     {
         if (cashSettlementBusinessDaysNode.Attributes["href"] != null || cashSettlementBusinessDaysNode.Attributes["id"] != null) 
         {
             if (cashSettlementBusinessDaysNode.Attributes["id"] != null) 
             {
                 cashSettlementBusinessDaysIDRef_ = cashSettlementBusinessDaysNode.Attributes["id"].Value;
                 XsdTypeNonNegativeInteger ob = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
                 IDManager.SetID(cashSettlementBusinessDaysIDRef_, ob);
             }
             else if (cashSettlementBusinessDaysNode.Attributes["href"] != null)
             {
                 cashSettlementBusinessDaysIDRef_ = cashSettlementBusinessDaysNode.Attributes["href"].Value;
             }
             else
             {
                 cashSettlementBusinessDays_ = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
             }
         }
         else
         {
             cashSettlementBusinessDays_ = new XsdTypeNonNegativeInteger(cashSettlementBusinessDaysNode);
         }
     }
     
 
     XmlNode cashSettlementAmountNode = xmlNode.SelectSingleNode("cashSettlementAmount");
     
     if (cashSettlementAmountNode != null)
     {
         if (cashSettlementAmountNode.Attributes["href"] != null || cashSettlementAmountNode.Attributes["id"] != null) 
         {
             if (cashSettlementAmountNode.Attributes["id"] != null) 
             {
                 cashSettlementAmountIDRef_ = cashSettlementAmountNode.Attributes["id"].Value;
                 Money ob = new Money(cashSettlementAmountNode);
                 IDManager.SetID(cashSettlementAmountIDRef_, ob);
             }
             else if (cashSettlementAmountNode.Attributes["href"] != null)
             {
                 cashSettlementAmountIDRef_ = cashSettlementAmountNode.Attributes["href"].Value;
             }
             else
             {
                 cashSettlementAmount_ = new Money(cashSettlementAmountNode);
             }
         }
         else
         {
             cashSettlementAmount_ = new Money(cashSettlementAmountNode);
         }
     }
     
 
     XmlNode recoveryFactorNode = xmlNode.SelectSingleNode("recoveryFactor");
     
     if (recoveryFactorNode != null)
     {
         if (recoveryFactorNode.Attributes["href"] != null || recoveryFactorNode.Attributes["id"] != null) 
         {
             if (recoveryFactorNode.Attributes["id"] != null) 
             {
                 recoveryFactorIDRef_ = recoveryFactorNode.Attributes["id"].Value;
                 RestrictedPercentage ob = new RestrictedPercentage(recoveryFactorNode);
                 IDManager.SetID(recoveryFactorIDRef_, ob);
             }
             else if (recoveryFactorNode.Attributes["href"] != null)
             {
                 recoveryFactorIDRef_ = recoveryFactorNode.Attributes["href"].Value;
             }
             else
             {
                 recoveryFactor_ = new RestrictedPercentage(recoveryFactorNode);
             }
         }
         else
         {
             recoveryFactor_ = new RestrictedPercentage(recoveryFactorNode);
         }
     }
     
 
     XmlNode fixedSettlementNode = xmlNode.SelectSingleNode("fixedSettlement");
     
     if (fixedSettlementNode != null)
     {
         if (fixedSettlementNode.Attributes["href"] != null || fixedSettlementNode.Attributes["id"] != null) 
         {
             if (fixedSettlementNode.Attributes["id"] != null) 
             {
                 fixedSettlementIDRef_ = fixedSettlementNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(fixedSettlementNode);
                 IDManager.SetID(fixedSettlementIDRef_, ob);
             }
             else if (fixedSettlementNode.Attributes["href"] != null)
             {
                 fixedSettlementIDRef_ = fixedSettlementNode.Attributes["href"].Value;
             }
             else
             {
                 fixedSettlement_ = new XsdTypeBoolean(fixedSettlementNode);
             }
         }
         else
         {
             fixedSettlement_ = new XsdTypeBoolean(fixedSettlementNode);
         }
     }
     
 
     XmlNode accruedInterestNode = xmlNode.SelectSingleNode("accruedInterest");
     
     if (accruedInterestNode != null)
     {
         if (accruedInterestNode.Attributes["href"] != null || accruedInterestNode.Attributes["id"] != null) 
         {
             if (accruedInterestNode.Attributes["id"] != null) 
             {
                 accruedInterestIDRef_ = accruedInterestNode.Attributes["id"].Value;
                 XsdTypeBoolean ob = new XsdTypeBoolean(accruedInterestNode);
                 IDManager.SetID(accruedInterestIDRef_, ob);
             }
             else if (accruedInterestNode.Attributes["href"] != null)
             {
                 accruedInterestIDRef_ = accruedInterestNode.Attributes["href"].Value;
             }
             else
             {
                 accruedInterest_ = new XsdTypeBoolean(accruedInterestNode);
             }
         }
         else
         {
             accruedInterest_ = new XsdTypeBoolean(accruedInterestNode);
         }
     }
     
 
     XmlNode valuationMethodNode = xmlNode.SelectSingleNode("valuationMethod");
     
     if (valuationMethodNode != null)
     {
         if (valuationMethodNode.Attributes["href"] != null || valuationMethodNode.Attributes["id"] != null) 
         {
             if (valuationMethodNode.Attributes["id"] != null) 
             {
                 valuationMethodIDRef_ = valuationMethodNode.Attributes["id"].Value;
                 ValuationMethodEnum ob = new ValuationMethodEnum(valuationMethodNode);
                 IDManager.SetID(valuationMethodIDRef_, ob);
             }
             else if (valuationMethodNode.Attributes["href"] != null)
             {
                 valuationMethodIDRef_ = valuationMethodNode.Attributes["href"].Value;
             }
             else
             {
                 valuationMethod_ = new ValuationMethodEnum(valuationMethodNode);
             }
         }
         else
         {
             valuationMethod_ = new ValuationMethodEnum(valuationMethodNode);
         }
     }
     
 
 }