public NoteInfo(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode tradeDateNode = xmlNode.SelectSingleNode("tradeDate");

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


            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;
                        XsdTypeDate ob = new XsdTypeDate(effectiveDateNode);
                        IDManager.SetID(effectiveDateIDRef_, ob);
                    }
                    else if (effectiveDateNode.Attributes["href"] != null)
                    {
                        effectiveDateIDRef_ = effectiveDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        effectiveDate_ = new XsdTypeDate(effectiveDateNode);
                    }
                }
                else
                {
                    effectiveDate_ = new XsdTypeDate(effectiveDateNode);
                }
            }


            XmlNode maturityDateNode = xmlNode.SelectSingleNode("maturityDate");

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


            XmlNode calculationAmountNode = xmlNode.SelectSingleNode("calculationAmount");

            if (calculationAmountNode != null)
            {
                if (calculationAmountNode.Attributes["href"] != null || calculationAmountNode.Attributes["id"] != null)
                {
                    if (calculationAmountNode.Attributes["id"] != null)
                    {
                        calculationAmountIDRef_ = calculationAmountNode.Attributes["id"].Value;
                        CalculationAmount ob = new CalculationAmount(calculationAmountNode);
                        IDManager.SetID(calculationAmountIDRef_, ob);
                    }
                    else if (calculationAmountNode.Attributes["href"] != null)
                    {
                        calculationAmountIDRef_ = calculationAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAmount_ = new CalculationAmount(calculationAmountNode);
                    }
                }
                else
                {
                    calculationAmount_ = new CalculationAmount(calculationAmountNode);
                }
            }


            XmlNode premiumNode = xmlNode.SelectSingleNode("premium");

            if (premiumNode != null)
            {
                if (premiumNode.Attributes["href"] != null || premiumNode.Attributes["id"] != null)
                {
                    if (premiumNode.Attributes["id"] != null)
                    {
                        premiumIDRef_ = premiumNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(premiumNode);
                        IDManager.SetID(premiumIDRef_, ob);
                    }
                    else if (premiumNode.Attributes["href"] != null)
                    {
                        premiumIDRef_ = premiumNode.Attributes["href"].Value;
                    }
                    else
                    {
                        premium_ = new XsdTypeDouble(premiumNode);
                    }
                }
                else
                {
                    premium_ = new XsdTypeDouble(premiumNode);
                }
            }
        }
Example #2
0
        public TermstructureBase(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode typeNode = xmlNode.SelectSingleNode("type");

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


            XmlNode interpolationNode = xmlNode.SelectSingleNode("interpolation");

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


            XmlNode daycounterNode = xmlNode.SelectSingleNode("daycounter");

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


            XmlNode calendarNode = xmlNode.SelectSingleNode("calendar");

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


            XmlNode businessDayConventionNode = xmlNode.SelectSingleNode("businessDayConvention");

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


            XmlNodeList rateDataNodeList = xmlNode.SelectNodes("rateData");

            if (rateDataNodeList != null)
            {
                this.rateData_ = new List <RateData>();
                foreach (XmlNode item in rateDataNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            rateDataIDRef_ = item.Attributes["id"].Value;
                            rateData_.Add(new RateData(item));
                            IDManager.SetID(rateDataIDRef_, rateData_[rateData_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            rateDataIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            rateData_.Add(new RateData(item));
                        }
                    }
                    else
                    {
                        rateData_.Add(new RateData(item));
                    }
                }
            }
        }
        public PricingResult(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode cashflowNode = xmlNode.SelectSingleNode("cashflow");

            if (cashflowNode != null)
            {
                if (cashflowNode.Attributes["href"] != null || cashflowNode.Attributes["id"] != null)
                {
                    if (cashflowNode.Attributes["id"] != null)
                    {
                        cashflowIDRef_ = cashflowNode.Attributes["id"].Value;
                        Cashflow ob = new Cashflow(cashflowNode);
                        IDManager.SetID(cashflowIDRef_, ob);
                    }
                    else if (cashflowNode.Attributes["href"] != null)
                    {
                        cashflowIDRef_ = cashflowNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashflow_ = new Cashflow(cashflowNode);
                    }
                }
                else
                {
                    cashflow_ = new Cashflow(cashflowNode);
                }
            }


            XmlNode priceNode = xmlNode.SelectSingleNode("price");

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


            XmlNode unitPriceNode = xmlNode.SelectSingleNode("unitPrice");

            if (unitPriceNode != null)
            {
                if (unitPriceNode.Attributes["href"] != null || unitPriceNode.Attributes["id"] != null)
                {
                    if (unitPriceNode.Attributes["id"] != null)
                    {
                        unitPriceIDRef_ = unitPriceNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(unitPriceNode);
                        IDManager.SetID(unitPriceIDRef_, ob);
                    }
                    else if (unitPriceNode.Attributes["href"] != null)
                    {
                        unitPriceIDRef_ = unitPriceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        unitPrice_ = new XsdTypeDouble(unitPriceNode);
                    }
                }
                else
                {
                    unitPrice_ = new XsdTypeDouble(unitPriceNode);
                }
            }
        }
Example #4
0
        public NthDefault(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode typeNode = xmlNode.SelectSingleNode("type");

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


            XmlNode nthNode = xmlNode.SelectSingleNode("nth");

            if (nthNode != null)
            {
                if (nthNode.Attributes["href"] != null || nthNode.Attributes["id"] != null)
                {
                    if (nthNode.Attributes["id"] != null)
                    {
                        nthIDRef_ = nthNode.Attributes["id"].Value;
                        XsdTypeInt ob = new XsdTypeInt(nthNode);
                        IDManager.SetID(nthIDRef_, ob);
                    }
                    else if (nthNode.Attributes["href"] != null)
                    {
                        nthIDRef_ = nthNode.Attributes["href"].Value;
                    }
                    else
                    {
                        nth_ = new XsdTypeInt(nthNode);
                    }
                }
                else
                {
                    nth_ = new XsdTypeInt(nthNode);
                }
            }


            XmlNode correlationNode = xmlNode.SelectSingleNode("correlation");

            if (correlationNode != null)
            {
                if (correlationNode.Attributes["href"] != null || correlationNode.Attributes["id"] != null)
                {
                    if (correlationNode.Attributes["id"] != null)
                    {
                        correlationIDRef_ = correlationNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(correlationNode);
                        IDManager.SetID(correlationIDRef_, ob);
                    }
                    else if (correlationNode.Attributes["href"] != null)
                    {
                        correlationIDRef_ = correlationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        correlation_ = new XsdTypeDouble(correlationNode);
                    }
                }
                else
                {
                    correlation_ = new XsdTypeDouble(correlationNode);
                }
            }
        }
Example #5
0
        public Instrument(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode headerNode = xmlNode.SelectSingleNode("header");

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


            XmlNode issueInformationNode = xmlNode.SelectSingleNode("issueInformation");

            if (issueInformationNode != null)
            {
                if (issueInformationNode.Attributes["href"] != null || issueInformationNode.Attributes["id"] != null)
                {
                    if (issueInformationNode.Attributes["id"] != null)
                    {
                        issueInformationIDRef_ = issueInformationNode.Attributes["id"].Value;
                        IssueInformation ob = new IssueInformation(issueInformationNode);
                        IDManager.SetID(issueInformationIDRef_, ob);
                    }
                    else if (issueInformationNode.Attributes["href"] != null)
                    {
                        issueInformationIDRef_ = issueInformationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        issueInformation_ = new IssueInformation(issueInformationNode);
                    }
                }
                else
                {
                    issueInformation_ = new IssueInformation(issueInformationNode);
                }
            }


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

            if (calculationAgentNode != null)
            {
                if (calculationAgentNode.Attributes["href"] != null || calculationAgentNode.Attributes["id"] != null)
                {
                    if (calculationAgentNode.Attributes["id"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["id"].Value;
                        CalculationAgent ob = new CalculationAgent(calculationAgentNode);
                        IDManager.SetID(calculationAgentIDRef_, ob);
                    }
                    else if (calculationAgentNode.Attributes["href"] != null)
                    {
                        calculationAgentIDRef_ = calculationAgentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calculationAgent_ = new CalculationAgent(calculationAgentNode);
                    }
                }
                else
                {
                    calculationAgent_ = new CalculationAgent(calculationAgentNode);
                }
            }
        }
Example #6
0
        public CreditEvents(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode failureToPayNode = xmlNode.SelectSingleNode("failureToPay");

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


            XmlNode obligationAccelerationNode = xmlNode.SelectSingleNode("obligationAcceleration");

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


            XmlNode repudiationMoratoriumNode = xmlNode.SelectSingleNode("repudiationMoratorium");

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


            XmlNode restructuringNode = xmlNode.SelectSingleNode("restructuring");

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


            XmlNode defaultRequirementNode = xmlNode.SelectSingleNode("defaultRequirement");

            if (defaultRequirementNode != null)
            {
                if (defaultRequirementNode.Attributes["href"] != null || defaultRequirementNode.Attributes["id"] != null)
                {
                    if (defaultRequirementNode.Attributes["id"] != null)
                    {
                        defaultRequirementIDRef_ = defaultRequirementNode.Attributes["id"].Value;
                        XsdTypeToken ob = new XsdTypeToken(defaultRequirementNode);
                        IDManager.SetID(defaultRequirementIDRef_, ob);
                    }
                    else if (defaultRequirementNode.Attributes["href"] != null)
                    {
                        defaultRequirementIDRef_ = defaultRequirementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        defaultRequirement_ = new XsdTypeToken(defaultRequirementNode);
                    }
                }
                else
                {
                    defaultRequirement_ = new XsdTypeToken(defaultRequirementNode);
                }
            }
        }
        public CreditDefaultSwap(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode referenceInformationListNode = xmlNode.SelectSingleNode("referenceInformationList");

            if (referenceInformationListNode != null)
            {
                if (referenceInformationListNode.Attributes["href"] != null || referenceInformationListNode.Attributes["id"] != null)
                {
                    if (referenceInformationListNode.Attributes["id"] != null)
                    {
                        referenceInformationListIDRef_ = referenceInformationListNode.Attributes["id"].Value;
                        ReferenceInformationList ob = new ReferenceInformationList(referenceInformationListNode);
                        IDManager.SetID(referenceInformationListIDRef_, ob);
                    }
                    else if (referenceInformationListNode.Attributes["href"] != null)
                    {
                        referenceInformationListIDRef_ = referenceInformationListNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referenceInformationList_ = new ReferenceInformationList(referenceInformationListNode);
                    }
                }
                else
                {
                    referenceInformationList_ = new ReferenceInformationList(referenceInformationListNode);
                }
            }


            XmlNode protectionTermsNode = xmlNode.SelectSingleNode("protectionTerms");

            if (protectionTermsNode != null)
            {
                if (protectionTermsNode.Attributes["href"] != null || protectionTermsNode.Attributes["id"] != null)
                {
                    if (protectionTermsNode.Attributes["id"] != null)
                    {
                        protectionTermsIDRef_ = protectionTermsNode.Attributes["id"].Value;
                        ProtectionTerms ob = new ProtectionTerms(protectionTermsNode);
                        IDManager.SetID(protectionTermsIDRef_, ob);
                    }
                    else if (protectionTermsNode.Attributes["href"] != null)
                    {
                        protectionTermsIDRef_ = protectionTermsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        protectionTerms_ = new ProtectionTerms(protectionTermsNode);
                    }
                }
                else
                {
                    protectionTerms_ = new ProtectionTerms(protectionTermsNode);
                }
            }


            XmlNode swapStreamNode = xmlNode.SelectSingleNode("swapStream");

            if (swapStreamNode != null)
            {
                if (swapStreamNode.Attributes["href"] != null || swapStreamNode.Attributes["id"] != null)
                {
                    if (swapStreamNode.Attributes["id"] != null)
                    {
                        swapStreamIDRef_ = swapStreamNode.Attributes["id"].Value;
                        SwapStream ob = new SwapStream(swapStreamNode);
                        IDManager.SetID(swapStreamIDRef_, ob);
                    }
                    else if (swapStreamNode.Attributes["href"] != null)
                    {
                        swapStreamIDRef_ = swapStreamNode.Attributes["href"].Value;
                    }
                    else
                    {
                        swapStream_ = new SwapStream(swapStreamNode);
                    }
                }
                else
                {
                    swapStream_ = new SwapStream(swapStreamNode);
                }
            }
        }
Example #8
0
        public Pricing(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode evaluationTimeNode = xmlNode.SelectSingleNode("evaluationTime");

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


            XmlNode pricingParameterNode = xmlNode.SelectSingleNode("pricingParameter");

            if (pricingParameterNode != null)
            {
                if (pricingParameterNode.Attributes["href"] != null || pricingParameterNode.Attributes["id"] != null)
                {
                    if (pricingParameterNode.Attributes["id"] != null)
                    {
                        pricingParameterIDRef_ = pricingParameterNode.Attributes["id"].Value;
                        PricingParameter ob = new PricingParameter(pricingParameterNode);
                        IDManager.SetID(pricingParameterIDRef_, ob);
                    }
                    else if (pricingParameterNode.Attributes["href"] != null)
                    {
                        pricingParameterIDRef_ = pricingParameterNode.Attributes["href"].Value;
                    }
                    else
                    {
                        pricingParameter_ = new PricingParameter(pricingParameterNode);
                    }
                }
                else
                {
                    pricingParameter_ = new PricingParameter(pricingParameterNode);
                }
            }


            XmlNode pricingResultNode = xmlNode.SelectSingleNode("pricingResult");

            if (pricingResultNode != null)
            {
                if (pricingResultNode.Attributes["href"] != null || pricingResultNode.Attributes["id"] != null)
                {
                    if (pricingResultNode.Attributes["id"] != null)
                    {
                        pricingResultIDRef_ = pricingResultNode.Attributes["id"].Value;
                        PricingResult ob = new PricingResult(pricingResultNode);
                        IDManager.SetID(pricingResultIDRef_, ob);
                    }
                    else if (pricingResultNode.Attributes["href"] != null)
                    {
                        pricingResultIDRef_ = pricingResultNode.Attributes["href"].Value;
                    }
                    else
                    {
                        pricingResult_ = new PricingResult(pricingResultNode);
                    }
                }
                else
                {
                    pricingResult_ = new PricingResult(pricingResultNode);
                }
            }
        }
        public RateData(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode periodMultiplierNode = xmlNode.SelectSingleNode("periodMultiplier");

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


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

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


            XmlNode dataNode = xmlNode.SelectSingleNode("data");

            if (dataNode != null)
            {
                if (dataNode.Attributes["href"] != null || dataNode.Attributes["id"] != null)
                {
                    if (dataNode.Attributes["id"] != null)
                    {
                        dataIDRef_ = dataNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(dataNode);
                        IDManager.SetID(dataIDRef_, ob);
                    }
                    else if (dataNode.Attributes["href"] != null)
                    {
                        dataIDRef_ = dataNode.Attributes["href"].Value;
                    }
                    else
                    {
                        data_ = new XsdTypeDouble(dataNode);
                    }
                }
                else
                {
                    data_ = new XsdTypeDouble(dataNode);
                }
            }
        }
        public ReferenceInformation(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode referenceEntityNode = xmlNode.SelectSingleNode("referenceEntity");

            if (referenceEntityNode != null)
            {
                if (referenceEntityNode.Attributes["href"] != null || referenceEntityNode.Attributes["id"] != null)
                {
                    if (referenceEntityNode.Attributes["id"] != null)
                    {
                        referenceEntityIDRef_ = referenceEntityNode.Attributes["id"].Value;
                        ReferenceEntity ob = new ReferenceEntity(referenceEntityNode);
                        IDManager.SetID(referenceEntityIDRef_, ob);
                    }
                    else if (referenceEntityNode.Attributes["href"] != null)
                    {
                        referenceEntityIDRef_ = referenceEntityNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referenceEntity_ = new ReferenceEntity(referenceEntityNode);
                    }
                }
                else
                {
                    referenceEntity_ = new ReferenceEntity(referenceEntityNode);
                }
            }


            XmlNode referenceObligationNode = xmlNode.SelectSingleNode("referenceObligation");

            if (referenceObligationNode != null)
            {
                if (referenceObligationNode.Attributes["href"] != null || referenceObligationNode.Attributes["id"] != null)
                {
                    if (referenceObligationNode.Attributes["id"] != null)
                    {
                        referenceObligationIDRef_ = referenceObligationNode.Attributes["id"].Value;
                        ReferenceObligation ob = new ReferenceObligation(referenceObligationNode);
                        IDManager.SetID(referenceObligationIDRef_, ob);
                    }
                    else if (referenceObligationNode.Attributes["href"] != null)
                    {
                        referenceObligationIDRef_ = referenceObligationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referenceObligation_ = new ReferenceObligation(referenceObligationNode);
                    }
                }
                else
                {
                    referenceObligation_ = new ReferenceObligation(referenceObligationNode);
                }
            }


            XmlNode referencePriceNode = xmlNode.SelectSingleNode("referencePrice");

            if (referencePriceNode != null)
            {
                if (referencePriceNode.Attributes["href"] != null || referencePriceNode.Attributes["id"] != null)
                {
                    if (referencePriceNode.Attributes["id"] != null)
                    {
                        referencePriceIDRef_ = referencePriceNode.Attributes["id"].Value;
                        XsdTypeDouble ob = new XsdTypeDouble(referencePriceNode);
                        IDManager.SetID(referencePriceIDRef_, ob);
                    }
                    else if (referencePriceNode.Attributes["href"] != null)
                    {
                        referencePriceIDRef_ = referencePriceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referencePrice_ = new XsdTypeDouble(referencePriceNode);
                    }
                }
                else
                {
                    referencePrice_ = new XsdTypeDouble(referencePriceNode);
                }
            }
        }
Example #11
0
        public IssueInformation(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode swapInfoNode = xmlNode.SelectSingleNode("swapInfo");

            if (swapInfoNode != null)
            {
                if (swapInfoNode.Attributes["href"] != null || swapInfoNode.Attributes["id"] != null)
                {
                    if (swapInfoNode.Attributes["id"] != null)
                    {
                        swapInfoIDRef_ = swapInfoNode.Attributes["id"].Value;
                        SwapInfo ob = new SwapInfo(swapInfoNode);
                        IDManager.SetID(swapInfoIDRef_, ob);
                    }
                    else if (swapInfoNode.Attributes["href"] != null)
                    {
                        swapInfoIDRef_ = swapInfoNode.Attributes["href"].Value;
                    }
                    else
                    {
                        swapInfo_ = new SwapInfo(swapInfoNode);
                    }
                }
                else
                {
                    swapInfo_ = new SwapInfo(swapInfoNode);
                }
            }


            XmlNode noteInfoNode = xmlNode.SelectSingleNode("noteInfo");

            if (noteInfoNode != null)
            {
                if (noteInfoNode.Attributes["href"] != null || noteInfoNode.Attributes["id"] != null)
                {
                    if (noteInfoNode.Attributes["id"] != null)
                    {
                        noteInfoIDRef_ = noteInfoNode.Attributes["id"].Value;
                        NoteInfo ob = new NoteInfo(noteInfoNode);
                        IDManager.SetID(noteInfoIDRef_, ob);
                    }
                    else if (noteInfoNode.Attributes["href"] != null)
                    {
                        noteInfoIDRef_ = noteInfoNode.Attributes["href"].Value;
                    }
                    else
                    {
                        noteInfo_ = new NoteInfo(noteInfoNode);
                    }
                }
                else
                {
                    noteInfo_ = new NoteInfo(noteInfoNode);
                }
            }


            XmlNode securitiesInfoNode = xmlNode.SelectSingleNode("securitiesInfo");

            if (securitiesInfoNode != null)
            {
                if (securitiesInfoNode.Attributes["href"] != null || securitiesInfoNode.Attributes["id"] != null)
                {
                    if (securitiesInfoNode.Attributes["id"] != null)
                    {
                        securitiesInfoIDRef_ = securitiesInfoNode.Attributes["id"].Value;
                        SecuritiesInfo ob = new SecuritiesInfo(securitiesInfoNode);
                        IDManager.SetID(securitiesInfoIDRef_, ob);
                    }
                    else if (securitiesInfoNode.Attributes["href"] != null)
                    {
                        securitiesInfoIDRef_ = securitiesInfoNode.Attributes["href"].Value;
                    }
                    else
                    {
                        securitiesInfo_ = new SecuritiesInfo(securitiesInfoNode);
                    }
                }
                else
                {
                    securitiesInfo_ = new SecuritiesInfo(securitiesInfoNode);
                }
            }
        }