Exemple #1
0
        public Period(XmlNode xmlNode)
        {
            XmlNode periodMultiplierNode = xmlNode.SelectSingleNode("periodMultiplier");

            if (periodMultiplierNode != null)
            {
                if (periodMultiplierNode.Attributes["href"] != null || periodMultiplierNode.Attributes["id"] != null)
                {
                    if (periodMultiplierNode.Attributes["id"] != null)
                    {
                        periodMultiplierIDRef_ = periodMultiplierNode.Attributes["id"].Value;
                        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;
                        PeriodEnum ob = new PeriodEnum(periodNode);
                        IDManager.SetID(periodIDRef_, ob);
                    }
                    else if (periodNode.Attributes["href"] != null)
                    {
                        periodIDRef_ = periodNode.Attributes["href"].Value;
                    }
                    else
                    {
                        period_ = new PeriodEnum(periodNode);
                    }
                }
                else
                {
                    period_ = new PeriodEnum(periodNode);
                }
            }
        }
        public FormulaComponent(XmlNode xmlNode)
        {
            XmlNode componentDescriptionNode = xmlNode.SelectSingleNode("componentDescription");

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


            XmlNode formulaNode = xmlNode.SelectSingleNode("formula");

            if (formulaNode != null)
            {
                if (formulaNode.Attributes["href"] != null || formulaNode.Attributes["id"] != null)
                {
                    if (formulaNode.Attributes["id"] != null)
                    {
                        formulaIDRef_ = formulaNode.Attributes["id"].Value;
                        Formula ob = new Formula(formulaNode);
                        IDManager.SetID(formulaIDRef_, ob);
                    }
                    else if (formulaNode.Attributes["href"] != null)
                    {
                        formulaIDRef_ = formulaNode.Attributes["href"].Value;
                    }
                    else
                    {
                        formula_ = new Formula(formulaNode);
                    }
                }
                else
                {
                    formula_ = new Formula(formulaNode);
                }
            }
        }
Exemple #3
0
        public ReferenceBank(XmlNode xmlNode)
        {
            XmlNode referenceBankIdNode = xmlNode.SelectSingleNode("referenceBankId");

            if (referenceBankIdNode != null)
            {
                if (referenceBankIdNode.Attributes["href"] != null || referenceBankIdNode.Attributes["id"] != null)
                {
                    if (referenceBankIdNode.Attributes["id"] != null)
                    {
                        referenceBankIdIDRef_ = referenceBankIdNode.Attributes["id"].Value;
                        ReferenceBankId ob = new ReferenceBankId(referenceBankIdNode);
                        IDManager.SetID(referenceBankIdIDRef_, ob);
                    }
                    else if (referenceBankIdNode.Attributes["href"] != null)
                    {
                        referenceBankIdIDRef_ = referenceBankIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referenceBankId_ = new ReferenceBankId(referenceBankIdNode);
                    }
                }
                else
                {
                    referenceBankId_ = new ReferenceBankId(referenceBankIdNode);
                }
            }


            XmlNode referenceBankNameNode = xmlNode.SelectSingleNode("referenceBankName");

            if (referenceBankNameNode != null)
            {
                if (referenceBankNameNode.Attributes["href"] != null || referenceBankNameNode.Attributes["id"] != null)
                {
                    if (referenceBankNameNode.Attributes["id"] != null)
                    {
                        referenceBankNameIDRef_ = referenceBankNameNode.Attributes["id"].Value;
                        XsdTypeString ob = new XsdTypeString(referenceBankNameNode);
                        IDManager.SetID(referenceBankNameIDRef_, ob);
                    }
                    else if (referenceBankNameNode.Attributes["href"] != null)
                    {
                        referenceBankNameIDRef_ = referenceBankNameNode.Attributes["href"].Value;
                    }
                    else
                    {
                        referenceBankName_ = new XsdTypeString(referenceBankNameNode);
                    }
                }
                else
                {
                    referenceBankName_ = new XsdTypeString(referenceBankNameNode);
                }
            }
        }
        public ElectricityDeliveryUnitFirm(XmlNode xmlNode)
        {
            XmlNode applicableNode = xmlNode.SelectSingleNode("applicable");

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


            XmlNode generationAssetNode = xmlNode.SelectSingleNode("generationAsset");

            if (generationAssetNode != null)
            {
                if (generationAssetNode.Attributes["href"] != null || generationAssetNode.Attributes["id"] != null)
                {
                    if (generationAssetNode.Attributes["id"] != null)
                    {
                        generationAssetIDRef_ = generationAssetNode.Attributes["id"].Value;
                        CommodityDeliveryPoint ob = new CommodityDeliveryPoint(generationAssetNode);
                        IDManager.SetID(generationAssetIDRef_, ob);
                    }
                    else if (generationAssetNode.Attributes["href"] != null)
                    {
                        generationAssetIDRef_ = generationAssetNode.Attributes["href"].Value;
                    }
                    else
                    {
                        generationAsset_ = new CommodityDeliveryPoint(generationAssetNode);
                    }
                }
                else
                {
                    generationAsset_ = new CommodityDeliveryPoint(generationAssetNode);
                }
            }
        }
        public NotifyingParty(XmlNode xmlNode)
        {
            XmlNode buyerPartyReferenceNode = xmlNode.SelectSingleNode("buyerPartyReference");

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


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

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

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


            XmlNode rejectionLimitNode = xmlNode.SelectSingleNode("rejectionLimit");

            if (rejectionLimitNode != null)
            {
                if (rejectionLimitNode.Attributes["href"] != null || rejectionLimitNode.Attributes["id"] != null)
                {
                    if (rejectionLimitNode.Attributes["id"] != null)
                    {
                        rejectionLimitIDRef_ = rejectionLimitNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(rejectionLimitNode);
                        IDManager.SetID(rejectionLimitIDRef_, ob);
                    }
                    else if (rejectionLimitNode.Attributes["href"] != null)
                    {
                        rejectionLimitIDRef_ = rejectionLimitNode.Attributes["href"].Value;
                    }
                    else
                    {
                        rejectionLimit_ = new XsdTypeDecimal(rejectionLimitNode);
                    }
                }
                else
                {
                    rejectionLimit_ = new XsdTypeDecimal(rejectionLimitNode);
                }
            }
        }
        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);
                }
            }
        }
Exemple #8
0
        public ReturnSwapPaymentDates(XmlNode xmlNode)
        {
            XmlNode paymentDatesInterimNode = xmlNode.SelectSingleNode("paymentDatesInterim");

            if (paymentDatesInterimNode != null)
            {
                if (paymentDatesInterimNode.Attributes["href"] != null || paymentDatesInterimNode.Attributes["id"] != null)
                {
                    if (paymentDatesInterimNode.Attributes["id"] != null)
                    {
                        paymentDatesInterimIDRef_ = paymentDatesInterimNode.Attributes["id"].Value;
                        AdjustableOrRelativeDates ob = new AdjustableOrRelativeDates(paymentDatesInterimNode);
                        IDManager.SetID(paymentDatesInterimIDRef_, ob);
                    }
                    else if (paymentDatesInterimNode.Attributes["href"] != null)
                    {
                        paymentDatesInterimIDRef_ = paymentDatesInterimNode.Attributes["href"].Value;
                    }
                    else
                    {
                        paymentDatesInterim_ = new AdjustableOrRelativeDates(paymentDatesInterimNode);
                    }
                }
                else
                {
                    paymentDatesInterim_ = new AdjustableOrRelativeDates(paymentDatesInterimNode);
                }
            }


            XmlNode paymentDateFinalNode = xmlNode.SelectSingleNode("paymentDateFinal");

            if (paymentDateFinalNode != null)
            {
                if (paymentDateFinalNode.Attributes["href"] != null || paymentDateFinalNode.Attributes["id"] != null)
                {
                    if (paymentDateFinalNode.Attributes["id"] != null)
                    {
                        paymentDateFinalIDRef_ = paymentDateFinalNode.Attributes["id"].Value;
                        AdjustableOrRelativeDate ob = new AdjustableOrRelativeDate(paymentDateFinalNode);
                        IDManager.SetID(paymentDateFinalIDRef_, ob);
                    }
                    else if (paymentDateFinalNode.Attributes["href"] != null)
                    {
                        paymentDateFinalIDRef_ = paymentDateFinalNode.Attributes["href"].Value;
                    }
                    else
                    {
                        paymentDateFinal_ = new AdjustableOrRelativeDate(paymentDateFinalNode);
                    }
                }
                else
                {
                    paymentDateFinal_ = new AdjustableOrRelativeDate(paymentDateFinalNode);
                }
            }
        }
Exemple #9
0
        public FxMultipleExercise(XmlNode xmlNode)
        {
            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;
                        NonNegativeMoney ob = new NonNegativeMoney(minimumNotionalAmountNode);
                        IDManager.SetID(minimumNotionalAmountIDRef_, ob);
                    }
                    else if (minimumNotionalAmountNode.Attributes["href"] != null)
                    {
                        minimumNotionalAmountIDRef_ = minimumNotionalAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        minimumNotionalAmount_ = new NonNegativeMoney(minimumNotionalAmountNode);
                    }
                }
                else
                {
                    minimumNotionalAmount_ = new NonNegativeMoney(minimumNotionalAmountNode);
                }
            }


            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;
                        NonNegativeMoney ob = new NonNegativeMoney(maximumNotionalAmountNode);
                        IDManager.SetID(maximumNotionalAmountIDRef_, ob);
                    }
                    else if (maximumNotionalAmountNode.Attributes["href"] != null)
                    {
                        maximumNotionalAmountIDRef_ = maximumNotionalAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumNotionalAmount_ = new NonNegativeMoney(maximumNotionalAmountNode);
                    }
                }
                else
                {
                    maximumNotionalAmount_ = new NonNegativeMoney(maximumNotionalAmountNode);
                }
            }
        }
Exemple #10
0
        public DenominatorTerm(XmlNode xmlNode)
        {
            XmlNode weightedPartialNode = xmlNode.SelectSingleNode("weightedPartial");

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


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

            if (powerNode != null)
            {
                if (powerNode.Attributes["href"] != null || powerNode.Attributes["id"] != null)
                {
                    if (powerNode.Attributes["id"] != null)
                    {
                        powerIDRef_ = powerNode.Attributes["id"].Value;
                        XsdTypePositiveInteger ob = new XsdTypePositiveInteger(powerNode);
                        IDManager.SetID(powerIDRef_, ob);
                    }
                    else if (powerNode.Attributes["href"] != null)
                    {
                        powerIDRef_ = powerNode.Attributes["href"].Value;
                    }
                    else
                    {
                        power_ = new XsdTypePositiveInteger(powerNode);
                    }
                }
                else
                {
                    power_ = new XsdTypePositiveInteger(powerNode);
                }
            }
        }
Exemple #11
0
        public YieldCurveMethod(XmlNode xmlNode)
        {
            XmlNode settlementRateSourceNode = xmlNode.SelectSingleNode("settlementRateSource");

            if (settlementRateSourceNode != null)
            {
                if (settlementRateSourceNode.Attributes["href"] != null || settlementRateSourceNode.Attributes["id"] != null)
                {
                    if (settlementRateSourceNode.Attributes["id"] != null)
                    {
                        settlementRateSourceIDRef_ = settlementRateSourceNode.Attributes["id"].Value;
                        SettlementRateSource ob = new SettlementRateSource(settlementRateSourceNode);
                        IDManager.SetID(settlementRateSourceIDRef_, ob);
                    }
                    else if (settlementRateSourceNode.Attributes["href"] != null)
                    {
                        settlementRateSourceIDRef_ = settlementRateSourceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        settlementRateSource_ = new SettlementRateSource(settlementRateSourceNode);
                    }
                }
                else
                {
                    settlementRateSource_ = new SettlementRateSource(settlementRateSourceNode);
                }
            }


            XmlNode quotationRateTypeNode = xmlNode.SelectSingleNode("quotationRateType");

            if (quotationRateTypeNode != null)
            {
                if (quotationRateTypeNode.Attributes["href"] != null || quotationRateTypeNode.Attributes["id"] != null)
                {
                    if (quotationRateTypeNode.Attributes["id"] != null)
                    {
                        quotationRateTypeIDRef_ = quotationRateTypeNode.Attributes["id"].Value;
                        QuotationRateTypeEnum ob = new QuotationRateTypeEnum(quotationRateTypeNode);
                        IDManager.SetID(quotationRateTypeIDRef_, ob);
                    }
                    else if (quotationRateTypeNode.Attributes["href"] != null)
                    {
                        quotationRateTypeIDRef_ = quotationRateTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        quotationRateType_ = new QuotationRateTypeEnum(quotationRateTypeNode);
                    }
                }
                else
                {
                    quotationRateType_ = new QuotationRateTypeEnum(quotationRateTypeNode);
                }
            }
        }
        public StubCalculationPeriod(XmlNode xmlNode)
        {
            XmlNode initialStubNode = xmlNode.SelectSingleNode("initialStub");

            if (initialStubNode != null)
            {
                if (initialStubNode.Attributes["href"] != null || initialStubNode.Attributes["id"] != null)
                {
                    if (initialStubNode.Attributes["id"] != null)
                    {
                        initialStubIDRef_ = initialStubNode.Attributes["id"].Value;
                        Stub ob = new Stub(initialStubNode);
                        IDManager.SetID(initialStubIDRef_, ob);
                    }
                    else if (initialStubNode.Attributes["href"] != null)
                    {
                        initialStubIDRef_ = initialStubNode.Attributes["href"].Value;
                    }
                    else
                    {
                        initialStub_ = new Stub(initialStubNode);
                    }
                }
                else
                {
                    initialStub_ = new Stub(initialStubNode);
                }
            }


            XmlNode finalStubNode = xmlNode.SelectSingleNode("finalStub");

            if (finalStubNode != null)
            {
                if (finalStubNode.Attributes["href"] != null || finalStubNode.Attributes["id"] != null)
                {
                    if (finalStubNode.Attributes["id"] != null)
                    {
                        finalStubIDRef_ = finalStubNode.Attributes["id"].Value;
                        Stub ob = new Stub(finalStubNode);
                        IDManager.SetID(finalStubIDRef_, ob);
                    }
                    else if (finalStubNode.Attributes["href"] != null)
                    {
                        finalStubIDRef_ = finalStubNode.Attributes["href"].Value;
                    }
                    else
                    {
                        finalStub_ = new Stub(finalStubNode);
                    }
                }
                else
                {
                    finalStub_ = new Stub(finalStubNode);
                }
            }
        }
        public AdditionalPaymentAmount(XmlNode xmlNode)
        {
            XmlNode paymentAmountNode = xmlNode.SelectSingleNode("paymentAmount");

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


            XmlNode formulaNode = xmlNode.SelectSingleNode("formula");

            if (formulaNode != null)
            {
                if (formulaNode.Attributes["href"] != null || formulaNode.Attributes["id"] != null)
                {
                    if (formulaNode.Attributes["id"] != null)
                    {
                        formulaIDRef_ = formulaNode.Attributes["id"].Value;
                        Formula ob = new Formula(formulaNode);
                        IDManager.SetID(formulaIDRef_, ob);
                    }
                    else if (formulaNode.Attributes["href"] != null)
                    {
                        formulaIDRef_ = formulaNode.Attributes["href"].Value;
                    }
                    else
                    {
                        formula_ = new Formula(formulaNode);
                    }
                }
                else
                {
                    formula_ = new Formula(formulaNode);
                }
            }
        }
        public InstrumentTradeQuantity(XmlNode xmlNode)
        {
            XmlNode numberNode = xmlNode.SelectSingleNode("number");

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


            XmlNode nominalNode = xmlNode.SelectSingleNode("nominal");

            if (nominalNode != null)
            {
                if (nominalNode.Attributes["href"] != null || nominalNode.Attributes["id"] != null)
                {
                    if (nominalNode.Attributes["id"] != null)
                    {
                        nominalIDRef_ = nominalNode.Attributes["id"].Value;
                        Money ob = new Money(nominalNode);
                        IDManager.SetID(nominalIDRef_, ob);
                    }
                    else if (nominalNode.Attributes["href"] != null)
                    {
                        nominalIDRef_ = nominalNode.Attributes["href"].Value;
                    }
                    else
                    {
                        nominal_ = new Money(nominalNode);
                    }
                }
                else
                {
                    nominal_ = new Money(nominalNode);
                }
            }
        }
        public JointFunctionEvent(XmlNode xmlNode)
        {
            XmlNode jointTypeNode = xmlNode.SelectSingleNode("jointType");

            if (jointTypeNode != null)
            {
                if (jointTypeNode.Attributes["href"] != null || jointTypeNode.Attributes["id"] != null)
                {
                    if (jointTypeNode.Attributes["id"] != null)
                    {
                        jointTypeIDRef_ = jointTypeNode.Attributes["id"].Value;
                        JointTypeEnum ob = new JointTypeEnum(jointTypeNode);
                        IDManager.SetID(jointTypeIDRef_, ob);
                    }
                    else if (jointTypeNode.Attributes["href"] != null)
                    {
                        jointTypeIDRef_ = jointTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        jointType_ = new JointTypeEnum(jointTypeNode);
                    }
                }
                else
                {
                    jointType_ = new JointTypeEnum(jointTypeNode);
                }
            }


            XmlNode functionsNode = xmlNode.SelectSingleNode("functions");

            if (functionsNode != null)
            {
                if (functionsNode.Attributes["href"] != null || functionsNode.Attributes["id"] != null)
                {
                    if (functionsNode.Attributes["id"] != null)
                    {
                        functionsIDRef_ = functionsNode.Attributes["id"].Value;
                        Functions ob = new Functions(functionsNode);
                        IDManager.SetID(functionsIDRef_, ob);
                    }
                    else if (functionsNode.Attributes["href"] != null)
                    {
                        functionsIDRef_ = functionsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        functions_ = new Functions(functionsNode);
                    }
                }
                else
                {
                    functions_ = new Functions(functionsNode);
                }
            }
        }
Exemple #16
0
        public EEPRiskPeriod(XmlNode xmlNode)
        {
            XmlNode startDateNode = xmlNode.SelectSingleNode("startDate");

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


            XmlNode endDateNode = xmlNode.SelectSingleNode("endDate");

            if (endDateNode != null)
            {
                if (endDateNode.Attributes["href"] != null || endDateNode.Attributes["id"] != null)
                {
                    if (endDateNode.Attributes["id"] != null)
                    {
                        endDateIDRef_ = endDateNode.Attributes["id"].Value;
                        XsdTypeDate ob = new XsdTypeDate(endDateNode);
                        IDManager.SetID(endDateIDRef_, ob);
                    }
                    else if (endDateNode.Attributes["href"] != null)
                    {
                        endDateIDRef_ = endDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        endDate_ = new XsdTypeDate(endDateNode);
                    }
                }
                else
                {
                    endDate_ = new XsdTypeDate(endDateNode);
                }
            }
        }
Exemple #17
0
        public PremiumQuote(XmlNode xmlNode)
        {
            XmlNode valueNode = xmlNode.SelectSingleNode("value");

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


            XmlNode quoteBasisNode = xmlNode.SelectSingleNode("quoteBasis");

            if (quoteBasisNode != null)
            {
                if (quoteBasisNode.Attributes["href"] != null || quoteBasisNode.Attributes["id"] != null)
                {
                    if (quoteBasisNode.Attributes["id"] != null)
                    {
                        quoteBasisIDRef_ = quoteBasisNode.Attributes["id"].Value;
                        PremiumQuoteBasisEnum ob = new PremiumQuoteBasisEnum(quoteBasisNode);
                        IDManager.SetID(quoteBasisIDRef_, ob);
                    }
                    else if (quoteBasisNode.Attributes["href"] != null)
                    {
                        quoteBasisIDRef_ = quoteBasisNode.Attributes["href"].Value;
                    }
                    else
                    {
                        quoteBasis_ = new PremiumQuoteBasisEnum(quoteBasisNode);
                    }
                }
                else
                {
                    quoteBasis_ = new PremiumQuoteBasisEnum(quoteBasisNode);
                }
            }
        }
        public SettledEntityMatrix(XmlNode xmlNode)
        {
            XmlNode matrixSourceNode = xmlNode.SelectSingleNode("matrixSource");

            if (matrixSourceNode != null)
            {
                if (matrixSourceNode.Attributes["href"] != null || matrixSourceNode.Attributes["id"] != null)
                {
                    if (matrixSourceNode.Attributes["id"] != null)
                    {
                        matrixSourceIDRef_ = matrixSourceNode.Attributes["id"].Value;
                        MatrixSource ob = new MatrixSource(matrixSourceNode);
                        IDManager.SetID(matrixSourceIDRef_, ob);
                    }
                    else if (matrixSourceNode.Attributes["href"] != null)
                    {
                        matrixSourceIDRef_ = matrixSourceNode.Attributes["href"].Value;
                    }
                    else
                    {
                        matrixSource_ = new MatrixSource(matrixSourceNode);
                    }
                }
                else
                {
                    matrixSource_ = new MatrixSource(matrixSourceNode);
                }
            }


            XmlNode publicationDateNode = xmlNode.SelectSingleNode("publicationDate");

            if (publicationDateNode != null)
            {
                if (publicationDateNode.Attributes["href"] != null || publicationDateNode.Attributes["id"] != null)
                {
                    if (publicationDateNode.Attributes["id"] != null)
                    {
                        publicationDateIDRef_ = publicationDateNode.Attributes["id"].Value;
                        XsdTypeDate ob = new XsdTypeDate(publicationDateNode);
                        IDManager.SetID(publicationDateIDRef_, ob);
                    }
                    else if (publicationDateNode.Attributes["href"] != null)
                    {
                        publicationDateIDRef_ = publicationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        publicationDate_ = new XsdTypeDate(publicationDateNode);
                    }
                }
                else
                {
                    publicationDate_ = new XsdTypeDate(publicationDateNode);
                }
            }
        }
        public CommodityExercisePeriods(XmlNode xmlNode)
        {
            XmlNode commencementDateNode = xmlNode.SelectSingleNode("commencementDate");

            if (commencementDateNode != null)
            {
                if (commencementDateNode.Attributes["href"] != null || commencementDateNode.Attributes["id"] != null)
                {
                    if (commencementDateNode.Attributes["id"] != null)
                    {
                        commencementDateIDRef_ = commencementDateNode.Attributes["id"].Value;
                        AdjustableOrRelativeDate ob = new AdjustableOrRelativeDate(commencementDateNode);
                        IDManager.SetID(commencementDateIDRef_, ob);
                    }
                    else if (commencementDateNode.Attributes["href"] != null)
                    {
                        commencementDateIDRef_ = commencementDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        commencementDate_ = new AdjustableOrRelativeDate(commencementDateNode);
                    }
                }
                else
                {
                    commencementDate_ = new AdjustableOrRelativeDate(commencementDateNode);
                }
            }


            XmlNode expirationDateNode = xmlNode.SelectSingleNode("expirationDate");

            if (expirationDateNode != null)
            {
                if (expirationDateNode.Attributes["href"] != null || expirationDateNode.Attributes["id"] != null)
                {
                    if (expirationDateNode.Attributes["id"] != null)
                    {
                        expirationDateIDRef_ = expirationDateNode.Attributes["id"].Value;
                        AdjustableOrRelativeDate ob = new AdjustableOrRelativeDate(expirationDateNode);
                        IDManager.SetID(expirationDateIDRef_, ob);
                    }
                    else if (expirationDateNode.Attributes["href"] != null)
                    {
                        expirationDateIDRef_ = expirationDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        expirationDate_ = new AdjustableOrRelativeDate(expirationDateNode);
                    }
                }
                else
                {
                    expirationDate_ = new AdjustableOrRelativeDate(expirationDateNode);
                }
            }
        }
Exemple #20
0
        public SettlementProvision(XmlNode xmlNode)
        {
            XmlNode settlementCurrencyNode = xmlNode.SelectSingleNode("settlementCurrency");

            if (settlementCurrencyNode != null)
            {
                if (settlementCurrencyNode.Attributes["href"] != null || settlementCurrencyNode.Attributes["id"] != null)
                {
                    if (settlementCurrencyNode.Attributes["id"] != null)
                    {
                        settlementCurrencyIDRef_ = settlementCurrencyNode.Attributes["id"].Value;
                        Currency ob = new Currency(settlementCurrencyNode);
                        IDManager.SetID(settlementCurrencyIDRef_, ob);
                    }
                    else if (settlementCurrencyNode.Attributes["href"] != null)
                    {
                        settlementCurrencyIDRef_ = settlementCurrencyNode.Attributes["href"].Value;
                    }
                    else
                    {
                        settlementCurrency_ = new Currency(settlementCurrencyNode);
                    }
                }
                else
                {
                    settlementCurrency_ = new Currency(settlementCurrencyNode);
                }
            }


            XmlNode nonDeliverableSettlementNode = xmlNode.SelectSingleNode("nonDeliverableSettlement");

            if (nonDeliverableSettlementNode != null)
            {
                if (nonDeliverableSettlementNode.Attributes["href"] != null || nonDeliverableSettlementNode.Attributes["id"] != null)
                {
                    if (nonDeliverableSettlementNode.Attributes["id"] != null)
                    {
                        nonDeliverableSettlementIDRef_ = nonDeliverableSettlementNode.Attributes["id"].Value;
                        NonDeliverableSettlement ob = new NonDeliverableSettlement(nonDeliverableSettlementNode);
                        IDManager.SetID(nonDeliverableSettlementIDRef_, ob);
                    }
                    else if (nonDeliverableSettlementNode.Attributes["href"] != null)
                    {
                        nonDeliverableSettlementIDRef_ = nonDeliverableSettlementNode.Attributes["href"].Value;
                    }
                    else
                    {
                        nonDeliverableSettlement_ = new NonDeliverableSettlement(nonDeliverableSettlementNode);
                    }
                }
                else
                {
                    nonDeliverableSettlement_ = new NonDeliverableSettlement(nonDeliverableSettlementNode);
                }
            }
        }
        public AdjustableDatesOrRelativeDateOffset(XmlNode xmlNode)
        {
            XmlNode adjustableDatesNode = xmlNode.SelectSingleNode("adjustableDates");

            if (adjustableDatesNode != null)
            {
                if (adjustableDatesNode.Attributes["href"] != null || adjustableDatesNode.Attributes["id"] != null)
                {
                    if (adjustableDatesNode.Attributes["id"] != null)
                    {
                        adjustableDatesIDRef_ = adjustableDatesNode.Attributes["id"].Value;
                        AdjustableDates ob = new AdjustableDates(adjustableDatesNode);
                        IDManager.SetID(adjustableDatesIDRef_, ob);
                    }
                    else if (adjustableDatesNode.Attributes["href"] != null)
                    {
                        adjustableDatesIDRef_ = adjustableDatesNode.Attributes["href"].Value;
                    }
                    else
                    {
                        adjustableDates_ = new AdjustableDates(adjustableDatesNode);
                    }
                }
                else
                {
                    adjustableDates_ = new AdjustableDates(adjustableDatesNode);
                }
            }


            XmlNode relativeDateNode = xmlNode.SelectSingleNode("relativeDate");

            if (relativeDateNode != null)
            {
                if (relativeDateNode.Attributes["href"] != null || relativeDateNode.Attributes["id"] != null)
                {
                    if (relativeDateNode.Attributes["id"] != null)
                    {
                        relativeDateIDRef_ = relativeDateNode.Attributes["id"].Value;
                        RelativeDateOffset ob = new RelativeDateOffset(relativeDateNode);
                        IDManager.SetID(relativeDateIDRef_, ob);
                    }
                    else if (relativeDateNode.Attributes["href"] != null)
                    {
                        relativeDateIDRef_ = relativeDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        relativeDate_ = new RelativeDateOffset(relativeDateNode);
                    }
                }
                else
                {
                    relativeDate_ = new RelativeDateOffset(relativeDateNode);
                }
            }
        }
        public Underlyer(XmlNode xmlNode)
        {
            XmlNode singleUnderlyerNode = xmlNode.SelectSingleNode("singleUnderlyer");

            if (singleUnderlyerNode != null)
            {
                if (singleUnderlyerNode.Attributes["href"] != null || singleUnderlyerNode.Attributes["id"] != null)
                {
                    if (singleUnderlyerNode.Attributes["id"] != null)
                    {
                        singleUnderlyerIDRef_ = singleUnderlyerNode.Attributes["id"].Value;
                        SingleUnderlyer ob = new SingleUnderlyer(singleUnderlyerNode);
                        IDManager.SetID(singleUnderlyerIDRef_, ob);
                    }
                    else if (singleUnderlyerNode.Attributes["href"] != null)
                    {
                        singleUnderlyerIDRef_ = singleUnderlyerNode.Attributes["href"].Value;
                    }
                    else
                    {
                        singleUnderlyer_ = new SingleUnderlyer(singleUnderlyerNode);
                    }
                }
                else
                {
                    singleUnderlyer_ = new SingleUnderlyer(singleUnderlyerNode);
                }
            }


            XmlNode basketNode = xmlNode.SelectSingleNode("basket");

            if (basketNode != null)
            {
                if (basketNode.Attributes["href"] != null || basketNode.Attributes["id"] != null)
                {
                    if (basketNode.Attributes["id"] != null)
                    {
                        basketIDRef_ = basketNode.Attributes["id"].Value;
                        Basket ob = new Basket(basketNode);
                        IDManager.SetID(basketIDRef_, ob);
                    }
                    else if (basketNode.Attributes["href"] != null)
                    {
                        basketIDRef_ = basketNode.Attributes["href"].Value;
                    }
                    else
                    {
                        basket_ = new Basket(basketNode);
                    }
                }
                else
                {
                    basket_ = new Basket(basketNode);
                }
            }
        }
        public BoundedCorrelation(XmlNode xmlNode)
        {
            XmlNode minimumBoundaryPercentNode = xmlNode.SelectSingleNode("minimumBoundaryPercent");

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


            XmlNode maximumBoundaryPercentNode = xmlNode.SelectSingleNode("maximumBoundaryPercent");

            if (maximumBoundaryPercentNode != null)
            {
                if (maximumBoundaryPercentNode.Attributes["href"] != null || maximumBoundaryPercentNode.Attributes["id"] != null)
                {
                    if (maximumBoundaryPercentNode.Attributes["id"] != null)
                    {
                        maximumBoundaryPercentIDRef_ = maximumBoundaryPercentNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(maximumBoundaryPercentNode);
                        IDManager.SetID(maximumBoundaryPercentIDRef_, ob);
                    }
                    else if (maximumBoundaryPercentNode.Attributes["href"] != null)
                    {
                        maximumBoundaryPercentIDRef_ = maximumBoundaryPercentNode.Attributes["href"].Value;
                    }
                    else
                    {
                        maximumBoundaryPercent_ = new XsdTypeDecimal(maximumBoundaryPercentNode);
                    }
                }
                else
                {
                    maximumBoundaryPercent_ = new XsdTypeDecimal(maximumBoundaryPercentNode);
                }
            }
        }
Exemple #24
0
        public InterestAccrualsMethod(XmlNode xmlNode)
        {
            XmlNode floatingRateCalculationNode = xmlNode.SelectSingleNode("floatingRateCalculation");

            if (floatingRateCalculationNode != null)
            {
                if (floatingRateCalculationNode.Attributes["href"] != null || floatingRateCalculationNode.Attributes["id"] != null)
                {
                    if (floatingRateCalculationNode.Attributes["id"] != null)
                    {
                        floatingRateCalculationIDRef_ = floatingRateCalculationNode.Attributes["id"].Value;
                        FloatingRateCalculation ob = new FloatingRateCalculation(floatingRateCalculationNode);
                        IDManager.SetID(floatingRateCalculationIDRef_, ob);
                    }
                    else if (floatingRateCalculationNode.Attributes["href"] != null)
                    {
                        floatingRateCalculationIDRef_ = floatingRateCalculationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        floatingRateCalculation_ = new FloatingRateCalculation(floatingRateCalculationNode);
                    }
                }
                else
                {
                    floatingRateCalculation_ = new FloatingRateCalculation(floatingRateCalculationNode);
                }
            }


            XmlNode fixedRateNode = xmlNode.SelectSingleNode("fixedRate");

            if (fixedRateNode != null)
            {
                if (fixedRateNode.Attributes["href"] != null || fixedRateNode.Attributes["id"] != null)
                {
                    if (fixedRateNode.Attributes["id"] != null)
                    {
                        fixedRateIDRef_ = fixedRateNode.Attributes["id"].Value;
                        XsdTypeDecimal ob = new XsdTypeDecimal(fixedRateNode);
                        IDManager.SetID(fixedRateIDRef_, ob);
                    }
                    else if (fixedRateNode.Attributes["href"] != null)
                    {
                        fixedRateIDRef_ = fixedRateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        fixedRate_ = new XsdTypeDecimal(fixedRateNode);
                    }
                }
                else
                {
                    fixedRate_ = new XsdTypeDecimal(fixedRateNode);
                }
            }
        }
        public CoalProductSpecifications(XmlNode xmlNode)
        {
            XmlNode standardQualityNode = xmlNode.SelectSingleNode("standardQuality");

            if (standardQualityNode != null)
            {
                if (standardQualityNode.Attributes["href"] != null || standardQualityNode.Attributes["id"] != null)
                {
                    if (standardQualityNode.Attributes["id"] != null)
                    {
                        standardQualityIDRef_ = standardQualityNode.Attributes["id"].Value;
                        CoalStandardQuality ob = new CoalStandardQuality(standardQualityNode);
                        IDManager.SetID(standardQualityIDRef_, ob);
                    }
                    else if (standardQualityNode.Attributes["href"] != null)
                    {
                        standardQualityIDRef_ = standardQualityNode.Attributes["href"].Value;
                    }
                    else
                    {
                        standardQuality_ = new CoalStandardQuality(standardQualityNode);
                    }
                }
                else
                {
                    standardQuality_ = new CoalStandardQuality(standardQualityNode);
                }
            }


            XmlNode standardQualityScheduleNode = xmlNode.SelectSingleNode("standardQualitySchedule");

            if (standardQualityScheduleNode != null)
            {
                if (standardQualityScheduleNode.Attributes["href"] != null || standardQualityScheduleNode.Attributes["id"] != null)
                {
                    if (standardQualityScheduleNode.Attributes["id"] != null)
                    {
                        standardQualityScheduleIDRef_ = standardQualityScheduleNode.Attributes["id"].Value;
                        CoalStandardQualitySchedule ob = new CoalStandardQualitySchedule(standardQualityScheduleNode);
                        IDManager.SetID(standardQualityScheduleIDRef_, ob);
                    }
                    else if (standardQualityScheduleNode.Attributes["href"] != null)
                    {
                        standardQualityScheduleIDRef_ = standardQualityScheduleNode.Attributes["href"].Value;
                    }
                    else
                    {
                        standardQualitySchedule_ = new CoalStandardQualitySchedule(standardQualityScheduleNode);
                    }
                }
                else
                {
                    standardQualitySchedule_ = new CoalStandardQualitySchedule(standardQualityScheduleNode);
                }
            }
        }
        public EquityOptionTermination(XmlNode xmlNode)
        {
            XmlNode settlementAmountPaymentDateNode = xmlNode.SelectSingleNode("settlementAmountPaymentDate");

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


            XmlNode settlementAmountNode = xmlNode.SelectSingleNode("settlementAmount");

            if (settlementAmountNode != null)
            {
                if (settlementAmountNode.Attributes["href"] != null || settlementAmountNode.Attributes["id"] != null)
                {
                    if (settlementAmountNode.Attributes["id"] != null)
                    {
                        settlementAmountIDRef_ = settlementAmountNode.Attributes["id"].Value;
                        NonNegativeMoney ob = new NonNegativeMoney(settlementAmountNode);
                        IDManager.SetID(settlementAmountIDRef_, ob);
                    }
                    else if (settlementAmountNode.Attributes["href"] != null)
                    {
                        settlementAmountIDRef_ = settlementAmountNode.Attributes["href"].Value;
                    }
                    else
                    {
                        settlementAmount_ = new NonNegativeMoney(settlementAmountNode);
                    }
                }
                else
                {
                    settlementAmount_ = new NonNegativeMoney(settlementAmountNode);
                }
            }
        }
Exemple #27
0
        public Knock(XmlNode xmlNode)
        {
            XmlNode knockInNode = xmlNode.SelectSingleNode("knockIn");

            if (knockInNode != null)
            {
                if (knockInNode.Attributes["href"] != null || knockInNode.Attributes["id"] != null)
                {
                    if (knockInNode.Attributes["id"] != null)
                    {
                        knockInIDRef_ = knockInNode.Attributes["id"].Value;
                        TriggerEvent ob = new TriggerEvent(knockInNode);
                        IDManager.SetID(knockInIDRef_, ob);
                    }
                    else if (knockInNode.Attributes["href"] != null)
                    {
                        knockInIDRef_ = knockInNode.Attributes["href"].Value;
                    }
                    else
                    {
                        knockIn_ = new TriggerEvent(knockInNode);
                    }
                }
                else
                {
                    knockIn_ = new TriggerEvent(knockInNode);
                }
            }


            XmlNode knockOutNode = xmlNode.SelectSingleNode("knockOut");

            if (knockOutNode != null)
            {
                if (knockOutNode.Attributes["href"] != null || knockOutNode.Attributes["id"] != null)
                {
                    if (knockOutNode.Attributes["id"] != null)
                    {
                        knockOutIDRef_ = knockOutNode.Attributes["id"].Value;
                        TriggerEvent ob = new TriggerEvent(knockOutNode);
                        IDManager.SetID(knockOutIDRef_, ob);
                    }
                    else if (knockOutNode.Attributes["href"] != null)
                    {
                        knockOutIDRef_ = knockOutNode.Attributes["href"].Value;
                    }
                    else
                    {
                        knockOut_ = new TriggerEvent(knockOutNode);
                    }
                }
                else
                {
                    knockOut_ = new TriggerEvent(knockOutNode);
                }
            }
        }
Exemple #28
0
        public StrikeSpread(XmlNode xmlNode)
        {
            XmlNode upperStrikeNode = xmlNode.SelectSingleNode("upperStrike");

            if (upperStrikeNode != null)
            {
                if (upperStrikeNode.Attributes["href"] != null || upperStrikeNode.Attributes["id"] != null)
                {
                    if (upperStrikeNode.Attributes["id"] != null)
                    {
                        upperStrikeIDRef_ = upperStrikeNode.Attributes["id"].Value;
                        OptionStrike ob = new OptionStrike(upperStrikeNode);
                        IDManager.SetID(upperStrikeIDRef_, ob);
                    }
                    else if (upperStrikeNode.Attributes["href"] != null)
                    {
                        upperStrikeIDRef_ = upperStrikeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        upperStrike_ = new OptionStrike(upperStrikeNode);
                    }
                }
                else
                {
                    upperStrike_ = new OptionStrike(upperStrikeNode);
                }
            }


            XmlNode upperStrikeNumberOfOptionsNode = xmlNode.SelectSingleNode("upperStrikeNumberOfOptions");

            if (upperStrikeNumberOfOptionsNode != null)
            {
                if (upperStrikeNumberOfOptionsNode.Attributes["href"] != null || upperStrikeNumberOfOptionsNode.Attributes["id"] != null)
                {
                    if (upperStrikeNumberOfOptionsNode.Attributes["id"] != null)
                    {
                        upperStrikeNumberOfOptionsIDRef_ = upperStrikeNumberOfOptionsNode.Attributes["id"].Value;
                        PositiveDecimal ob = new PositiveDecimal(upperStrikeNumberOfOptionsNode);
                        IDManager.SetID(upperStrikeNumberOfOptionsIDRef_, ob);
                    }
                    else if (upperStrikeNumberOfOptionsNode.Attributes["href"] != null)
                    {
                        upperStrikeNumberOfOptionsIDRef_ = upperStrikeNumberOfOptionsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        upperStrikeNumberOfOptions_ = new PositiveDecimal(upperStrikeNumberOfOptionsNode);
                    }
                }
                else
                {
                    upperStrikeNumberOfOptions_ = new PositiveDecimal(upperStrikeNumberOfOptionsNode);
                }
            }
        }
        public StrategyFeature(XmlNode xmlNode)
        {
            XmlNode strikeSpreadNode = xmlNode.SelectSingleNode("strikeSpread");

            if (strikeSpreadNode != null)
            {
                if (strikeSpreadNode.Attributes["href"] != null || strikeSpreadNode.Attributes["id"] != null)
                {
                    if (strikeSpreadNode.Attributes["id"] != null)
                    {
                        strikeSpreadIDRef_ = strikeSpreadNode.Attributes["id"].Value;
                        StrikeSpread ob = new StrikeSpread(strikeSpreadNode);
                        IDManager.SetID(strikeSpreadIDRef_, ob);
                    }
                    else if (strikeSpreadNode.Attributes["href"] != null)
                    {
                        strikeSpreadIDRef_ = strikeSpreadNode.Attributes["href"].Value;
                    }
                    else
                    {
                        strikeSpread_ = new StrikeSpread(strikeSpreadNode);
                    }
                }
                else
                {
                    strikeSpread_ = new StrikeSpread(strikeSpreadNode);
                }
            }


            XmlNode calendarSpreadNode = xmlNode.SelectSingleNode("calendarSpread");

            if (calendarSpreadNode != null)
            {
                if (calendarSpreadNode.Attributes["href"] != null || calendarSpreadNode.Attributes["id"] != null)
                {
                    if (calendarSpreadNode.Attributes["id"] != null)
                    {
                        calendarSpreadIDRef_ = calendarSpreadNode.Attributes["id"].Value;
                        CalendarSpread ob = new CalendarSpread(calendarSpreadNode);
                        IDManager.SetID(calendarSpreadIDRef_, ob);
                    }
                    else if (calendarSpreadNode.Attributes["href"] != null)
                    {
                        calendarSpreadIDRef_ = calendarSpreadNode.Attributes["href"].Value;
                    }
                    else
                    {
                        calendarSpread_ = new CalendarSpread(calendarSpreadNode);
                    }
                }
                else
                {
                    calendarSpread_ = new CalendarSpread(calendarSpreadNode);
                }
            }
        }
        public PrevailingTime(XmlNode xmlNode)
        {
            XmlNode hourMinuteTimeNode = xmlNode.SelectSingleNode("hourMinuteTime");

            if (hourMinuteTimeNode != null)
            {
                if (hourMinuteTimeNode.Attributes["href"] != null || hourMinuteTimeNode.Attributes["id"] != null)
                {
                    if (hourMinuteTimeNode.Attributes["id"] != null)
                    {
                        hourMinuteTimeIDRef_ = hourMinuteTimeNode.Attributes["id"].Value;
                        HourMinuteTime ob = new HourMinuteTime(hourMinuteTimeNode);
                        IDManager.SetID(hourMinuteTimeIDRef_, ob);
                    }
                    else if (hourMinuteTimeNode.Attributes["href"] != null)
                    {
                        hourMinuteTimeIDRef_ = hourMinuteTimeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        hourMinuteTime_ = new HourMinuteTime(hourMinuteTimeNode);
                    }
                }
                else
                {
                    hourMinuteTime_ = new HourMinuteTime(hourMinuteTimeNode);
                }
            }


            XmlNode locationNode = xmlNode.SelectSingleNode("location");

            if (locationNode != null)
            {
                if (locationNode.Attributes["href"] != null || locationNode.Attributes["id"] != null)
                {
                    if (locationNode.Attributes["id"] != null)
                    {
                        locationIDRef_ = locationNode.Attributes["id"].Value;
                        TimezoneLocation ob = new TimezoneLocation(locationNode);
                        IDManager.SetID(locationIDRef_, ob);
                    }
                    else if (locationNode.Attributes["href"] != null)
                    {
                        locationIDRef_ = locationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        location_ = new TimezoneLocation(locationNode);
                    }
                }
                else
                {
                    location_ = new TimezoneLocation(locationNode);
                }
            }
        }