public DateTimeList(XmlNode xmlNode)
        {
            XmlNodeList dateTimeNodeList = xmlNode.SelectNodes("dateTime");

            foreach (XmlNode item in dateTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        dateTimeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = new XsdTypeDateTime();
                        ob.Add(new XsdTypeDateTime(item));
                        IDManager.SetID(dateTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        dateTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        dateTime.Add(new XsdTypeDateTime(item));
                    }
                }
            }
        }
        public TradeTimestamp(XmlNode xmlNode)
        {
            XmlNodeList typeNodeList = xmlNode.SelectNodes("type");

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

            foreach (XmlNode item in typeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        typeIDRef = item.Attributes["id"].Name;
                        TimestampTypeScheme ob = TimestampTypeScheme();
                        IDManager.SetID(typeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        typeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        type = new TimestampTypeScheme(item);
                    }
                }
            }


            XmlNodeList valueNodeList = xmlNode.SelectNodes("value");

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

            foreach (XmlNode item in valueNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        valueIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(valueIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        valueIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        value = new XsdTypeDateTime(item);
                    }
                }
            }
        }
 public TradeTimestamp(XmlNode 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;
                 TimestampTypeScheme ob = new TimestampTypeScheme(typeNode);
                 IDManager.SetID(typeIDRef_, ob);
             }
             else if (typeNode.Attributes["href"] != null)
             {
                 typeIDRef_ = typeNode.Attributes["href"].Value;
             }
             else
             {
                 type_ = new TimestampTypeScheme(typeNode);
             }
         }
         else
         {
             type_ = new TimestampTypeScheme(typeNode);
         }
     }
     
 
     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;
                 XsdTypeDateTime ob = new XsdTypeDateTime(valueNode);
                 IDManager.SetID(valueIDRef_, ob);
             }
             else if (valueNode.Attributes["href"] != null)
             {
                 valueIDRef_ = valueNode.Attributes["href"].Value;
             }
             else
             {
                 value_ = new XsdTypeDateTime(valueNode);
             }
         }
         else
         {
             value_ = new XsdTypeDateTime(valueNode);
         }
     }
     
 
 }
        public TradeTimestamp(XmlNode 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;
                        TimestampTypeScheme ob = new TimestampTypeScheme(typeNode);
                        IDManager.SetID(typeIDRef_, ob);
                    }
                    else if (typeNode.Attributes["href"] != null)
                    {
                        typeIDRef_ = typeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        type_ = new TimestampTypeScheme(typeNode);
                    }
                }
                else
                {
                    type_ = new TimestampTypeScheme(typeNode);
                }
            }


            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;
                        XsdTypeDateTime ob = new XsdTypeDateTime(valueNode);
                        IDManager.SetID(valueIDRef_, ob);
                    }
                    else if (valueNode.Attributes["href"] != null)
                    {
                        valueIDRef_ = valueNode.Attributes["href"].Value;
                    }
                    else
                    {
                        value_ = new XsdTypeDateTime(valueNode);
                    }
                }
                else
                {
                    value_ = new XsdTypeDateTime(valueNode);
                }
            }
        }
示例#5
0
        public ClearingStatusItem(XmlNode xmlNode)
        {
            XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");

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


            XmlNodeList tradeReferenceInformationNodeList = xmlNode.SelectNodes("tradeReferenceInformation");

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

            foreach (XmlNode item in tradeReferenceInformationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        tradeReferenceInformationIDRef = item.Attributes["id"].Name;
                        TradeReferenceInformation ob = TradeReferenceInformation();
                        IDManager.SetID(tradeReferenceInformationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        tradeReferenceInformationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        tradeReferenceInformation = new TradeReferenceInformation(item);
                    }
                }
            }


            XmlNodeList tradeNodeList = xmlNode.SelectNodes("trade");

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

            foreach (XmlNode item in tradeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        tradeIDRef = item.Attributes["id"].Name;
                        Trade ob = Trade();
                        IDManager.SetID(tradeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        tradeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        trade = new Trade(item);
                    }
                }
            }


            XmlNodeList clearingStatusValueNodeList = xmlNode.SelectNodes("clearingStatusValue");

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

            foreach (XmlNode item in clearingStatusValueNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        clearingStatusValueIDRef = item.Attributes["id"].Name;
                        ClearingStatusValue ob = ClearingStatusValue();
                        IDManager.SetID(clearingStatusValueIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        clearingStatusValueIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        clearingStatusValue = new ClearingStatusValue(item);
                    }
                }
            }


            XmlNodeList updatedDateTimeNodeList = xmlNode.SelectNodes("updatedDateTime");

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

            foreach (XmlNode item in updatedDateTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        updatedDateTimeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(updatedDateTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        updatedDateTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        updatedDateTime = new XsdTypeDateTime(item);
                    }
                }
            }


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

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


            XmlNodeList statusAppliesToNodeList = xmlNode.SelectNodes("statusAppliesTo");

            foreach (XmlNode item in statusAppliesToNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        statusAppliesToIDRef = item.Attributes["id"].Name;
                        List <PartyReference> ob = new List <PartyReference>();
                        ob.Add(new PartyReference(item));
                        IDManager.SetID(statusAppliesToIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        statusAppliesToIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        statusAppliesTo.Add(new PartyReference(item));
                    }
                }
            }
        }
        public RequestMessageHeader(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList sentByNodeList = xmlNode.SelectNodes("sentBy");

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

            foreach (XmlNode item in sentByNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        sentByIDRef = item.Attributes["id"].Name;
                        MessageAddress ob = MessageAddress();
                        IDManager.SetID(sentByIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        sentByIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        sentBy = new MessageAddress(item);
                    }
                }
            }


            XmlNodeList sendToNodeList = xmlNode.SelectNodes("sendTo");

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


            XmlNodeList copyToNodeList = xmlNode.SelectNodes("copyTo");

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


            XmlNodeList creationTimestampNodeList = xmlNode.SelectNodes("creationTimestamp");

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

            foreach (XmlNode item in creationTimestampNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        creationTimestampIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(creationTimestampIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        creationTimestampIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        creationTimestamp = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList expiryTimestampNodeList = xmlNode.SelectNodes("expiryTimestamp");

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

            foreach (XmlNode item in expiryTimestampNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        expiryTimestampIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(expiryTimestampIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        expiryTimestampIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        expiryTimestamp = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList implementationSpecificationNodeList = xmlNode.SelectNodes("implementationSpecification");

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

            foreach (XmlNode item in implementationSpecificationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        implementationSpecificationIDRef = item.Attributes["id"].Name;
                        ImplementationSpecification ob = ImplementationSpecification();
                        IDManager.SetID(implementationSpecificationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        implementationSpecificationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        implementationSpecification = new ImplementationSpecification(item);
                    }
                }
            }


            XmlNodeList partyMessageInformationNodeList = xmlNode.SelectNodes("partyMessageInformation");

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


            XmlNodeList SignatureNodeList = xmlNode.SelectNodes("Signature");

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

            foreach (XmlNode item in SignatureNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        SignatureIDRef = item.Attributes["id"].Name;
                        SignatureType ob = SignatureType();
                        IDManager.SetID(SignatureIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        SignatureIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        Signature = new SignatureType(item);
                    }
                }
            }
        }
        public WeightedAveragingObservation(XmlNode xmlNode)
        {
            XmlNode dateTimeNode = xmlNode.SelectSingleNode("dateTime");

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


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

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


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

            if (weightNode != null)
            {
                if (weightNode.Attributes["href"] != null || weightNode.Attributes["id"] != null)
                {
                    if (weightNode.Attributes["id"] != null)
                    {
                        weightIDRef_ = weightNode.Attributes["id"].Value;
                        NonNegativeDecimal ob = new NonNegativeDecimal(weightNode);
                        IDManager.SetID(weightIDRef_, ob);
                    }
                    else if (weightNode.Attributes["href"] != null)
                    {
                        weightIDRef_ = weightNode.Attributes["href"].Value;
                    }
                    else
                    {
                        weight_ = new NonNegativeDecimal(weightNode);
                    }
                }
                else
                {
                    weight_ = new NonNegativeDecimal(weightNode);
                }
            }
        }
 public PricingStructurePoint(XmlNode xmlNode)
 {
     XmlNode coordinateNode = xmlNode.SelectSingleNode("coordinate");
     
     if (coordinateNode != null)
     {
         if (coordinateNode.Attributes["href"] != null || coordinateNode.Attributes["id"] != null) 
         {
             if (coordinateNode.Attributes["id"] != null) 
             {
                 coordinateIDRef_ = coordinateNode.Attributes["id"].Value;
                 PricingDataPointCoordinate ob = new PricingDataPointCoordinate(coordinateNode);
                 IDManager.SetID(coordinateIDRef_, ob);
             }
             else if (coordinateNode.Attributes["href"] != null)
             {
                 coordinateIDRef_ = coordinateNode.Attributes["href"].Value;
             }
             else
             {
                 coordinate_ = new PricingDataPointCoordinate(coordinateNode);
             }
         }
         else
         {
             coordinate_ = new PricingDataPointCoordinate(coordinateNode);
         }
     }
     
 
     XmlNode coordinateReferenceNode = xmlNode.SelectSingleNode("coordinateReference");
     
     if (coordinateReferenceNode != null)
     {
         if (coordinateReferenceNode.Attributes["href"] != null || coordinateReferenceNode.Attributes["id"] != null) 
         {
             if (coordinateReferenceNode.Attributes["id"] != null) 
             {
                 coordinateReferenceIDRef_ = coordinateReferenceNode.Attributes["id"].Value;
                 PricingDataPointCoordinateReference ob = new PricingDataPointCoordinateReference(coordinateReferenceNode);
                 IDManager.SetID(coordinateReferenceIDRef_, ob);
             }
             else if (coordinateReferenceNode.Attributes["href"] != null)
             {
                 coordinateReferenceIDRef_ = coordinateReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 coordinateReference_ = new PricingDataPointCoordinateReference(coordinateReferenceNode);
             }
         }
         else
         {
             coordinateReference_ = new PricingDataPointCoordinateReference(coordinateReferenceNode);
         }
     }
     
 
     XmlNode underlyingAssetNode = xmlNode.SelectSingleNode("underlyingAsset");
     
     if (underlyingAssetNode != null)
     {
         if (underlyingAssetNode.Attributes["href"] != null || underlyingAssetNode.Attributes["id"] != null) 
         {
             if (underlyingAssetNode.Attributes["id"] != null) 
             {
                 underlyingAssetIDRef_ = underlyingAssetNode.Attributes["id"].Value;
                 Asset ob = new Asset(underlyingAssetNode);
                 IDManager.SetID(underlyingAssetIDRef_, ob);
             }
             else if (underlyingAssetNode.Attributes["href"] != null)
             {
                 underlyingAssetIDRef_ = underlyingAssetNode.Attributes["href"].Value;
             }
             else
             {
                 underlyingAsset_ = new Asset(underlyingAssetNode);
             }
         }
         else
         {
             underlyingAsset_ = new Asset(underlyingAssetNode);
         }
     }
     
 
     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);
         }
     }
     
 
     XmlNode bondNode = xmlNode.SelectSingleNode("bond");
     
     if (bondNode != null)
     {
         if (bondNode.Attributes["href"] != null || bondNode.Attributes["id"] != null) 
         {
             if (bondNode.Attributes["id"] != null) 
             {
                 bondIDRef_ = bondNode.Attributes["id"].Value;
                 Bond ob = new Bond(bondNode);
                 IDManager.SetID(bondIDRef_, ob);
             }
             else if (bondNode.Attributes["href"] != null)
             {
                 bondIDRef_ = bondNode.Attributes["href"].Value;
             }
             else
             {
                 bond_ = new Bond(bondNode);
             }
         }
         else
         {
             bond_ = new Bond(bondNode);
         }
     }
     
 
     XmlNode cashNode = xmlNode.SelectSingleNode("cash");
     
     if (cashNode != null)
     {
         if (cashNode.Attributes["href"] != null || cashNode.Attributes["id"] != null) 
         {
             if (cashNode.Attributes["id"] != null) 
             {
                 cashIDRef_ = cashNode.Attributes["id"].Value;
                 Cash ob = new Cash(cashNode);
                 IDManager.SetID(cashIDRef_, ob);
             }
             else if (cashNode.Attributes["href"] != null)
             {
                 cashIDRef_ = cashNode.Attributes["href"].Value;
             }
             else
             {
                 cash_ = new Cash(cashNode);
             }
         }
         else
         {
             cash_ = new Cash(cashNode);
         }
     }
     
 
     XmlNode commodityNode = xmlNode.SelectSingleNode("commodity");
     
     if (commodityNode != null)
     {
         if (commodityNode.Attributes["href"] != null || commodityNode.Attributes["id"] != null) 
         {
             if (commodityNode.Attributes["id"] != null) 
             {
                 commodityIDRef_ = commodityNode.Attributes["id"].Value;
                 Commodity ob = new Commodity(commodityNode);
                 IDManager.SetID(commodityIDRef_, ob);
             }
             else if (commodityNode.Attributes["href"] != null)
             {
                 commodityIDRef_ = commodityNode.Attributes["href"].Value;
             }
             else
             {
                 commodity_ = new Commodity(commodityNode);
             }
         }
         else
         {
             commodity_ = new Commodity(commodityNode);
         }
     }
     
 
     XmlNode convertibleBondNode = xmlNode.SelectSingleNode("convertibleBond");
     
     if (convertibleBondNode != null)
     {
         if (convertibleBondNode.Attributes["href"] != null || convertibleBondNode.Attributes["id"] != null) 
         {
             if (convertibleBondNode.Attributes["id"] != null) 
             {
                 convertibleBondIDRef_ = convertibleBondNode.Attributes["id"].Value;
                 ConvertibleBond ob = new ConvertibleBond(convertibleBondNode);
                 IDManager.SetID(convertibleBondIDRef_, ob);
             }
             else if (convertibleBondNode.Attributes["href"] != null)
             {
                 convertibleBondIDRef_ = convertibleBondNode.Attributes["href"].Value;
             }
             else
             {
                 convertibleBond_ = new ConvertibleBond(convertibleBondNode);
             }
         }
         else
         {
             convertibleBond_ = new ConvertibleBond(convertibleBondNode);
         }
     }
     
 
     XmlNode equityNode = xmlNode.SelectSingleNode("equity");
     
     if (equityNode != null)
     {
         if (equityNode.Attributes["href"] != null || equityNode.Attributes["id"] != null) 
         {
             if (equityNode.Attributes["id"] != null) 
             {
                 equityIDRef_ = equityNode.Attributes["id"].Value;
                 EquityAsset ob = new EquityAsset(equityNode);
                 IDManager.SetID(equityIDRef_, ob);
             }
             else if (equityNode.Attributes["href"] != null)
             {
                 equityIDRef_ = equityNode.Attributes["href"].Value;
             }
             else
             {
                 equity_ = new EquityAsset(equityNode);
             }
         }
         else
         {
             equity_ = new EquityAsset(equityNode);
         }
     }
     
 
     XmlNode exchangeTradedFundNode = xmlNode.SelectSingleNode("exchangeTradedFund");
     
     if (exchangeTradedFundNode != null)
     {
         if (exchangeTradedFundNode.Attributes["href"] != null || exchangeTradedFundNode.Attributes["id"] != null) 
         {
             if (exchangeTradedFundNode.Attributes["id"] != null) 
             {
                 exchangeTradedFundIDRef_ = exchangeTradedFundNode.Attributes["id"].Value;
                 ExchangeTradedFund ob = new ExchangeTradedFund(exchangeTradedFundNode);
                 IDManager.SetID(exchangeTradedFundIDRef_, ob);
             }
             else if (exchangeTradedFundNode.Attributes["href"] != null)
             {
                 exchangeTradedFundIDRef_ = exchangeTradedFundNode.Attributes["href"].Value;
             }
             else
             {
                 exchangeTradedFund_ = new ExchangeTradedFund(exchangeTradedFundNode);
             }
         }
         else
         {
             exchangeTradedFund_ = new ExchangeTradedFund(exchangeTradedFundNode);
         }
     }
     
 
     XmlNode futureNode = xmlNode.SelectSingleNode("future");
     
     if (futureNode != null)
     {
         if (futureNode.Attributes["href"] != null || futureNode.Attributes["id"] != null) 
         {
             if (futureNode.Attributes["id"] != null) 
             {
                 futureIDRef_ = futureNode.Attributes["id"].Value;
                 Future ob = new Future(futureNode);
                 IDManager.SetID(futureIDRef_, ob);
             }
             else if (futureNode.Attributes["href"] != null)
             {
                 futureIDRef_ = futureNode.Attributes["href"].Value;
             }
             else
             {
                 future_ = new Future(futureNode);
             }
         }
         else
         {
             future_ = new Future(futureNode);
         }
     }
     
 
     XmlNode indexNode = xmlNode.SelectSingleNode("index");
     
     if (indexNode != null)
     {
         if (indexNode.Attributes["href"] != null || indexNode.Attributes["id"] != null) 
         {
             if (indexNode.Attributes["id"] != null) 
             {
                 indexIDRef_ = indexNode.Attributes["id"].Value;
                 Index ob = new Index(indexNode);
                 IDManager.SetID(indexIDRef_, ob);
             }
             else if (indexNode.Attributes["href"] != null)
             {
                 indexIDRef_ = indexNode.Attributes["href"].Value;
             }
             else
             {
                 index_ = new Index(indexNode);
             }
         }
         else
         {
             index_ = new Index(indexNode);
         }
     }
     
 
     XmlNode loanNode = xmlNode.SelectSingleNode("loan");
     
     if (loanNode != null)
     {
         if (loanNode.Attributes["href"] != null || loanNode.Attributes["id"] != null) 
         {
             if (loanNode.Attributes["id"] != null) 
             {
                 loanIDRef_ = loanNode.Attributes["id"].Value;
                 Loan ob = new Loan(loanNode);
                 IDManager.SetID(loanIDRef_, ob);
             }
             else if (loanNode.Attributes["href"] != null)
             {
                 loanIDRef_ = loanNode.Attributes["href"].Value;
             }
             else
             {
                 loan_ = new Loan(loanNode);
             }
         }
         else
         {
             loan_ = new Loan(loanNode);
         }
     }
     
 
     XmlNode mortgageNode = xmlNode.SelectSingleNode("mortgage");
     
     if (mortgageNode != null)
     {
         if (mortgageNode.Attributes["href"] != null || mortgageNode.Attributes["id"] != null) 
         {
             if (mortgageNode.Attributes["id"] != null) 
             {
                 mortgageIDRef_ = mortgageNode.Attributes["id"].Value;
                 Mortgage ob = new Mortgage(mortgageNode);
                 IDManager.SetID(mortgageIDRef_, ob);
             }
             else if (mortgageNode.Attributes["href"] != null)
             {
                 mortgageIDRef_ = mortgageNode.Attributes["href"].Value;
             }
             else
             {
                 mortgage_ = new Mortgage(mortgageNode);
             }
         }
         else
         {
             mortgage_ = new Mortgage(mortgageNode);
         }
     }
     
 
     XmlNode mutualFundNode = xmlNode.SelectSingleNode("mutualFund");
     
     if (mutualFundNode != null)
     {
         if (mutualFundNode.Attributes["href"] != null || mutualFundNode.Attributes["id"] != null) 
         {
             if (mutualFundNode.Attributes["id"] != null) 
             {
                 mutualFundIDRef_ = mutualFundNode.Attributes["id"].Value;
                 MutualFund ob = new MutualFund(mutualFundNode);
                 IDManager.SetID(mutualFundIDRef_, ob);
             }
             else if (mutualFundNode.Attributes["href"] != null)
             {
                 mutualFundIDRef_ = mutualFundNode.Attributes["href"].Value;
             }
             else
             {
                 mutualFund_ = new MutualFund(mutualFundNode);
             }
         }
         else
         {
             mutualFund_ = new MutualFund(mutualFundNode);
         }
     }
     
 
     XmlNode underlyingAssetReferenceNode = xmlNode.SelectSingleNode("underlyingAssetReference");
     
     if (underlyingAssetReferenceNode != null)
     {
         if (underlyingAssetReferenceNode.Attributes["href"] != null || underlyingAssetReferenceNode.Attributes["id"] != null) 
         {
             if (underlyingAssetReferenceNode.Attributes["id"] != null) 
             {
                 underlyingAssetReferenceIDRef_ = underlyingAssetReferenceNode.Attributes["id"].Value;
                 AssetReference ob = new AssetReference(underlyingAssetReferenceNode);
                 IDManager.SetID(underlyingAssetReferenceIDRef_, ob);
             }
             else if (underlyingAssetReferenceNode.Attributes["href"] != null)
             {
                 underlyingAssetReferenceIDRef_ = underlyingAssetReferenceNode.Attributes["href"].Value;
             }
             else
             {
                 underlyingAssetReference_ = new AssetReference(underlyingAssetReferenceNode);
             }
         }
         else
         {
             underlyingAssetReference_ = new AssetReference(underlyingAssetReferenceNode);
         }
     }
     
 
     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 measureTypeNode = xmlNode.SelectSingleNode("measureType");
     
     if (measureTypeNode != null)
     {
         if (measureTypeNode.Attributes["href"] != null || measureTypeNode.Attributes["id"] != null) 
         {
             if (measureTypeNode.Attributes["id"] != null) 
             {
                 measureTypeIDRef_ = measureTypeNode.Attributes["id"].Value;
                 AssetMeasureType ob = new AssetMeasureType(measureTypeNode);
                 IDManager.SetID(measureTypeIDRef_, ob);
             }
             else if (measureTypeNode.Attributes["href"] != null)
             {
                 measureTypeIDRef_ = measureTypeNode.Attributes["href"].Value;
             }
             else
             {
                 measureType_ = new AssetMeasureType(measureTypeNode);
             }
         }
         else
         {
             measureType_ = new AssetMeasureType(measureTypeNode);
         }
     }
     
 
     XmlNode quoteUnitsNode = xmlNode.SelectSingleNode("quoteUnits");
     
     if (quoteUnitsNode != null)
     {
         if (quoteUnitsNode.Attributes["href"] != null || quoteUnitsNode.Attributes["id"] != null) 
         {
             if (quoteUnitsNode.Attributes["id"] != null) 
             {
                 quoteUnitsIDRef_ = quoteUnitsNode.Attributes["id"].Value;
                 PriceQuoteUnits ob = new PriceQuoteUnits(quoteUnitsNode);
                 IDManager.SetID(quoteUnitsIDRef_, ob);
             }
             else if (quoteUnitsNode.Attributes["href"] != null)
             {
                 quoteUnitsIDRef_ = quoteUnitsNode.Attributes["href"].Value;
             }
             else
             {
                 quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
             }
         }
         else
         {
             quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
         }
     }
     
 
     XmlNode sideNode = xmlNode.SelectSingleNode("side");
     
     if (sideNode != null)
     {
         if (sideNode.Attributes["href"] != null || sideNode.Attributes["id"] != null) 
         {
             if (sideNode.Attributes["id"] != null) 
             {
                 sideIDRef_ = sideNode.Attributes["id"].Value;
                 QuotationSideEnum ob = new QuotationSideEnum(sideNode);
                 IDManager.SetID(sideIDRef_, ob);
             }
             else if (sideNode.Attributes["href"] != null)
             {
                 sideIDRef_ = sideNode.Attributes["href"].Value;
             }
             else
             {
                 side_ = new QuotationSideEnum(sideNode);
             }
         }
         else
         {
             side_ = new QuotationSideEnum(sideNode);
         }
     }
     
 
     XmlNode currencyNode = xmlNode.SelectSingleNode("currency");
     
     if (currencyNode != null)
     {
         if (currencyNode.Attributes["href"] != null || currencyNode.Attributes["id"] != null) 
         {
             if (currencyNode.Attributes["id"] != null) 
             {
                 currencyIDRef_ = currencyNode.Attributes["id"].Value;
                 Currency ob = new Currency(currencyNode);
                 IDManager.SetID(currencyIDRef_, ob);
             }
             else if (currencyNode.Attributes["href"] != null)
             {
                 currencyIDRef_ = currencyNode.Attributes["href"].Value;
             }
             else
             {
                 currency_ = new Currency(currencyNode);
             }
         }
         else
         {
             currency_ = new Currency(currencyNode);
         }
     }
     
 
     XmlNode currencyTypeNode = xmlNode.SelectSingleNode("currencyType");
     
     if (currencyTypeNode != null)
     {
         if (currencyTypeNode.Attributes["href"] != null || currencyTypeNode.Attributes["id"] != null) 
         {
             if (currencyTypeNode.Attributes["id"] != null) 
             {
                 currencyTypeIDRef_ = currencyTypeNode.Attributes["id"].Value;
                 ReportingCurrencyType ob = new ReportingCurrencyType(currencyTypeNode);
                 IDManager.SetID(currencyTypeIDRef_, ob);
             }
             else if (currencyTypeNode.Attributes["href"] != null)
             {
                 currencyTypeIDRef_ = currencyTypeNode.Attributes["href"].Value;
             }
             else
             {
                 currencyType_ = new ReportingCurrencyType(currencyTypeNode);
             }
         }
         else
         {
             currencyType_ = new ReportingCurrencyType(currencyTypeNode);
         }
     }
     
 
     XmlNode timingNode = xmlNode.SelectSingleNode("timing");
     
     if (timingNode != null)
     {
         if (timingNode.Attributes["href"] != null || timingNode.Attributes["id"] != null) 
         {
             if (timingNode.Attributes["id"] != null) 
             {
                 timingIDRef_ = timingNode.Attributes["id"].Value;
                 QuoteTiming ob = new QuoteTiming(timingNode);
                 IDManager.SetID(timingIDRef_, ob);
             }
             else if (timingNode.Attributes["href"] != null)
             {
                 timingIDRef_ = timingNode.Attributes["href"].Value;
             }
             else
             {
                 timing_ = new QuoteTiming(timingNode);
             }
         }
         else
         {
             timing_ = new QuoteTiming(timingNode);
         }
     }
     
 
     XmlNode businessCenterNode = xmlNode.SelectSingleNode("businessCenter");
     
     if (businessCenterNode != null)
     {
         if (businessCenterNode.Attributes["href"] != null || businessCenterNode.Attributes["id"] != null) 
         {
             if (businessCenterNode.Attributes["id"] != null) 
             {
                 businessCenterIDRef_ = businessCenterNode.Attributes["id"].Value;
                 BusinessCenter ob = new BusinessCenter(businessCenterNode);
                 IDManager.SetID(businessCenterIDRef_, ob);
             }
             else if (businessCenterNode.Attributes["href"] != null)
             {
                 businessCenterIDRef_ = businessCenterNode.Attributes["href"].Value;
             }
             else
             {
                 businessCenter_ = new BusinessCenter(businessCenterNode);
             }
         }
         else
         {
             businessCenter_ = new BusinessCenter(businessCenterNode);
         }
     }
     
 
     XmlNode exchangeIdNode = xmlNode.SelectSingleNode("exchangeId");
     
     if (exchangeIdNode != null)
     {
         if (exchangeIdNode.Attributes["href"] != null || exchangeIdNode.Attributes["id"] != null) 
         {
             if (exchangeIdNode.Attributes["id"] != null) 
             {
                 exchangeIdIDRef_ = exchangeIdNode.Attributes["id"].Value;
                 ExchangeId ob = new ExchangeId(exchangeIdNode);
                 IDManager.SetID(exchangeIdIDRef_, ob);
             }
             else if (exchangeIdNode.Attributes["href"] != null)
             {
                 exchangeIdIDRef_ = exchangeIdNode.Attributes["href"].Value;
             }
             else
             {
                 exchangeId_ = new ExchangeId(exchangeIdNode);
             }
         }
         else
         {
             exchangeId_ = new ExchangeId(exchangeIdNode);
         }
     }
     
 
     XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");
     
     if (informationSourceNodeList != null)
     {
         this.informationSource_ = new List<InformationSource>();
         foreach (XmlNode item in informationSourceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     informationSourceIDRef_ = item.Attributes["id"].Value;
                     informationSource_.Add(new InformationSource(item));
                     IDManager.SetID(informationSourceIDRef_, informationSource_[informationSource_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     informationSourceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 informationSource_.Add(new InformationSource(item));
                 }
             }
             else
             {
                 informationSource_.Add(new InformationSource(item));
             }
         }
     }
     
 
     XmlNode pricingModelNode = xmlNode.SelectSingleNode("pricingModel");
     
     if (pricingModelNode != null)
     {
         if (pricingModelNode.Attributes["href"] != null || pricingModelNode.Attributes["id"] != null) 
         {
             if (pricingModelNode.Attributes["id"] != null) 
             {
                 pricingModelIDRef_ = pricingModelNode.Attributes["id"].Value;
                 PricingModel ob = new PricingModel(pricingModelNode);
                 IDManager.SetID(pricingModelIDRef_, ob);
             }
             else if (pricingModelNode.Attributes["href"] != null)
             {
                 pricingModelIDRef_ = pricingModelNode.Attributes["href"].Value;
             }
             else
             {
                 pricingModel_ = new PricingModel(pricingModelNode);
             }
         }
         else
         {
             pricingModel_ = new PricingModel(pricingModelNode);
         }
     }
     
 
     XmlNode timeNode = xmlNode.SelectSingleNode("time");
     
     if (timeNode != null)
     {
         if (timeNode.Attributes["href"] != null || timeNode.Attributes["id"] != null) 
         {
             if (timeNode.Attributes["id"] != null) 
             {
                 timeIDRef_ = timeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(timeNode);
                 IDManager.SetID(timeIDRef_, ob);
             }
             else if (timeNode.Attributes["href"] != null)
             {
                 timeIDRef_ = timeNode.Attributes["href"].Value;
             }
             else
             {
                 time_ = new XsdTypeDateTime(timeNode);
             }
         }
         else
         {
             time_ = new XsdTypeDateTime(timeNode);
         }
     }
     
 
     XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");
     
     if (valuationDateNode != null)
     {
         if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null) 
         {
             if (valuationDateNode.Attributes["id"] != null) 
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(valuationDateNode);
                 IDManager.SetID(valuationDateIDRef_, ob);
             }
             else if (valuationDateNode.Attributes["href"] != null)
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
             }
             else
             {
                 valuationDate_ = new XsdTypeDate(valuationDateNode);
             }
         }
         else
         {
             valuationDate_ = new XsdTypeDate(valuationDateNode);
         }
     }
     
 
     XmlNode expiryTimeNode = xmlNode.SelectSingleNode("expiryTime");
     
     if (expiryTimeNode != null)
     {
         if (expiryTimeNode.Attributes["href"] != null || expiryTimeNode.Attributes["id"] != null) 
         {
             if (expiryTimeNode.Attributes["id"] != null) 
             {
                 expiryTimeIDRef_ = expiryTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(expiryTimeNode);
                 IDManager.SetID(expiryTimeIDRef_, ob);
             }
             else if (expiryTimeNode.Attributes["href"] != null)
             {
                 expiryTimeIDRef_ = expiryTimeNode.Attributes["href"].Value;
             }
             else
             {
                 expiryTime_ = new XsdTypeDateTime(expiryTimeNode);
             }
         }
         else
         {
             expiryTime_ = new XsdTypeDateTime(expiryTimeNode);
         }
     }
     
 
     XmlNode cashflowTypeNode = xmlNode.SelectSingleNode("cashflowType");
     
     if (cashflowTypeNode != null)
     {
         if (cashflowTypeNode.Attributes["href"] != null || cashflowTypeNode.Attributes["id"] != null) 
         {
             if (cashflowTypeNode.Attributes["id"] != null) 
             {
                 cashflowTypeIDRef_ = cashflowTypeNode.Attributes["id"].Value;
                 CashflowType ob = new CashflowType(cashflowTypeNode);
                 IDManager.SetID(cashflowTypeIDRef_, ob);
             }
             else if (cashflowTypeNode.Attributes["href"] != null)
             {
                 cashflowTypeIDRef_ = cashflowTypeNode.Attributes["href"].Value;
             }
             else
             {
                 cashflowType_ = new CashflowType(cashflowTypeNode);
             }
         }
         else
         {
             cashflowType_ = new CashflowType(cashflowTypeNode);
         }
     }
     
 
 }
        public PricingStructureValuation(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode baseDateNode = xmlNode.SelectSingleNode("baseDate");

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


            XmlNode spotDateNode = xmlNode.SelectSingleNode("spotDate");

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


            XmlNode inputDataDateNode = xmlNode.SelectSingleNode("inputDataDate");

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


            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;
                        IdentifiedDate ob = new IdentifiedDate(endDateNode);
                        IDManager.SetID(endDateIDRef_, ob);
                    }
                    else if (endDateNode.Attributes["href"] != null)
                    {
                        endDateIDRef_ = endDateNode.Attributes["href"].Value;
                    }
                    else
                    {
                        endDate_ = new IdentifiedDate(endDateNode);
                    }
                }
                else
                {
                    endDate_ = new IdentifiedDate(endDateNode);
                }
            }


            XmlNode buildDateTimeNode = xmlNode.SelectSingleNode("buildDateTime");

            if (buildDateTimeNode != null)
            {
                if (buildDateTimeNode.Attributes["href"] != null || buildDateTimeNode.Attributes["id"] != null)
                {
                    if (buildDateTimeNode.Attributes["id"] != null)
                    {
                        buildDateTimeIDRef_ = buildDateTimeNode.Attributes["id"].Value;
                        XsdTypeDateTime ob = new XsdTypeDateTime(buildDateTimeNode);
                        IDManager.SetID(buildDateTimeIDRef_, ob);
                    }
                    else if (buildDateTimeNode.Attributes["href"] != null)
                    {
                        buildDateTimeIDRef_ = buildDateTimeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        buildDateTime_ = new XsdTypeDateTime(buildDateTimeNode);
                    }
                }
                else
                {
                    buildDateTime_ = new XsdTypeDateTime(buildDateTimeNode);
                }
            }
        }
示例#10
0
        public ExceptionMessageHeader(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode inReplyToNode = xmlNode.SelectSingleNode("inReplyTo");

            if (inReplyToNode != null)
            {
                if (inReplyToNode.Attributes["href"] != null || inReplyToNode.Attributes["id"] != null)
                {
                    if (inReplyToNode.Attributes["id"] != null)
                    {
                        inReplyToIDRef_ = inReplyToNode.Attributes["id"].Value;
                        MessageId ob = new MessageId(inReplyToNode);
                        IDManager.SetID(inReplyToIDRef_, ob);
                    }
                    else if (inReplyToNode.Attributes["href"] != null)
                    {
                        inReplyToIDRef_ = inReplyToNode.Attributes["href"].Value;
                    }
                    else
                    {
                        inReplyTo_ = new MessageId(inReplyToNode);
                    }
                }
                else
                {
                    inReplyTo_ = new MessageId(inReplyToNode);
                }
            }


            XmlNode sentByNode = xmlNode.SelectSingleNode("sentBy");

            if (sentByNode != null)
            {
                if (sentByNode.Attributes["href"] != null || sentByNode.Attributes["id"] != null)
                {
                    if (sentByNode.Attributes["id"] != null)
                    {
                        sentByIDRef_ = sentByNode.Attributes["id"].Value;
                        MessageAddress ob = new MessageAddress(sentByNode);
                        IDManager.SetID(sentByIDRef_, ob);
                    }
                    else if (sentByNode.Attributes["href"] != null)
                    {
                        sentByIDRef_ = sentByNode.Attributes["href"].Value;
                    }
                    else
                    {
                        sentBy_ = new MessageAddress(sentByNode);
                    }
                }
                else
                {
                    sentBy_ = new MessageAddress(sentByNode);
                }
            }


            XmlNodeList sendToNodeList = xmlNode.SelectNodes("sendTo");

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


            XmlNodeList copyToNodeList = xmlNode.SelectNodes("copyTo");

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


            XmlNode creationTimestampNode = xmlNode.SelectSingleNode("creationTimestamp");

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


            XmlNode expiryTimestampNode = xmlNode.SelectSingleNode("expiryTimestamp");

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


            XmlNode implementationSpecificationNode = xmlNode.SelectSingleNode("implementationSpecification");

            if (implementationSpecificationNode != null)
            {
                if (implementationSpecificationNode.Attributes["href"] != null || implementationSpecificationNode.Attributes["id"] != null)
                {
                    if (implementationSpecificationNode.Attributes["id"] != null)
                    {
                        implementationSpecificationIDRef_ = implementationSpecificationNode.Attributes["id"].Value;
                        ImplementationSpecification ob = new ImplementationSpecification(implementationSpecificationNode);
                        IDManager.SetID(implementationSpecificationIDRef_, ob);
                    }
                    else if (implementationSpecificationNode.Attributes["href"] != null)
                    {
                        implementationSpecificationIDRef_ = implementationSpecificationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        implementationSpecification_ = new ImplementationSpecification(implementationSpecificationNode);
                    }
                }
                else
                {
                    implementationSpecification_ = new ImplementationSpecification(implementationSpecificationNode);
                }
            }


            XmlNodeList partyMessageInformationNodeList = xmlNode.SelectNodes("partyMessageInformation");

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


            XmlNode SignatureNode = xmlNode.SelectSingleNode("Signature");

            if (SignatureNode != null)
            {
                if (SignatureNode.Attributes["href"] != null || SignatureNode.Attributes["id"] != null)
                {
                    if (SignatureNode.Attributes["id"] != null)
                    {
                        SignatureIDRef_ = SignatureNode.Attributes["id"].Value;
                        SignatureType ob = new SignatureType(SignatureNode);
                        IDManager.SetID(SignatureIDRef_, ob);
                    }
                    else if (SignatureNode.Attributes["href"] != null)
                    {
                        SignatureIDRef_ = SignatureNode.Attributes["href"].Value;
                    }
                    else
                    {
                        Signature_ = new SignatureType(SignatureNode);
                    }
                }
                else
                {
                    Signature_ = new SignatureType(SignatureNode);
                }
            }
        }
 public BasicQuotation(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 measureTypeNode = xmlNode.SelectSingleNode("measureType");
     
     if (measureTypeNode != null)
     {
         if (measureTypeNode.Attributes["href"] != null || measureTypeNode.Attributes["id"] != null) 
         {
             if (measureTypeNode.Attributes["id"] != null) 
             {
                 measureTypeIDRef_ = measureTypeNode.Attributes["id"].Value;
                 AssetMeasureType ob = new AssetMeasureType(measureTypeNode);
                 IDManager.SetID(measureTypeIDRef_, ob);
             }
             else if (measureTypeNode.Attributes["href"] != null)
             {
                 measureTypeIDRef_ = measureTypeNode.Attributes["href"].Value;
             }
             else
             {
                 measureType_ = new AssetMeasureType(measureTypeNode);
             }
         }
         else
         {
             measureType_ = new AssetMeasureType(measureTypeNode);
         }
     }
     
 
     XmlNode quoteUnitsNode = xmlNode.SelectSingleNode("quoteUnits");
     
     if (quoteUnitsNode != null)
     {
         if (quoteUnitsNode.Attributes["href"] != null || quoteUnitsNode.Attributes["id"] != null) 
         {
             if (quoteUnitsNode.Attributes["id"] != null) 
             {
                 quoteUnitsIDRef_ = quoteUnitsNode.Attributes["id"].Value;
                 PriceQuoteUnits ob = new PriceQuoteUnits(quoteUnitsNode);
                 IDManager.SetID(quoteUnitsIDRef_, ob);
             }
             else if (quoteUnitsNode.Attributes["href"] != null)
             {
                 quoteUnitsIDRef_ = quoteUnitsNode.Attributes["href"].Value;
             }
             else
             {
                 quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
             }
         }
         else
         {
             quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
         }
     }
     
 
     XmlNode sideNode = xmlNode.SelectSingleNode("side");
     
     if (sideNode != null)
     {
         if (sideNode.Attributes["href"] != null || sideNode.Attributes["id"] != null) 
         {
             if (sideNode.Attributes["id"] != null) 
             {
                 sideIDRef_ = sideNode.Attributes["id"].Value;
                 QuotationSideEnum ob = new QuotationSideEnum(sideNode);
                 IDManager.SetID(sideIDRef_, ob);
             }
             else if (sideNode.Attributes["href"] != null)
             {
                 sideIDRef_ = sideNode.Attributes["href"].Value;
             }
             else
             {
                 side_ = new QuotationSideEnum(sideNode);
             }
         }
         else
         {
             side_ = new QuotationSideEnum(sideNode);
         }
     }
     
 
     XmlNode currencyNode = xmlNode.SelectSingleNode("currency");
     
     if (currencyNode != null)
     {
         if (currencyNode.Attributes["href"] != null || currencyNode.Attributes["id"] != null) 
         {
             if (currencyNode.Attributes["id"] != null) 
             {
                 currencyIDRef_ = currencyNode.Attributes["id"].Value;
                 Currency ob = new Currency(currencyNode);
                 IDManager.SetID(currencyIDRef_, ob);
             }
             else if (currencyNode.Attributes["href"] != null)
             {
                 currencyIDRef_ = currencyNode.Attributes["href"].Value;
             }
             else
             {
                 currency_ = new Currency(currencyNode);
             }
         }
         else
         {
             currency_ = new Currency(currencyNode);
         }
     }
     
 
     XmlNode currencyTypeNode = xmlNode.SelectSingleNode("currencyType");
     
     if (currencyTypeNode != null)
     {
         if (currencyTypeNode.Attributes["href"] != null || currencyTypeNode.Attributes["id"] != null) 
         {
             if (currencyTypeNode.Attributes["id"] != null) 
             {
                 currencyTypeIDRef_ = currencyTypeNode.Attributes["id"].Value;
                 ReportingCurrencyType ob = new ReportingCurrencyType(currencyTypeNode);
                 IDManager.SetID(currencyTypeIDRef_, ob);
             }
             else if (currencyTypeNode.Attributes["href"] != null)
             {
                 currencyTypeIDRef_ = currencyTypeNode.Attributes["href"].Value;
             }
             else
             {
                 currencyType_ = new ReportingCurrencyType(currencyTypeNode);
             }
         }
         else
         {
             currencyType_ = new ReportingCurrencyType(currencyTypeNode);
         }
     }
     
 
     XmlNode timingNode = xmlNode.SelectSingleNode("timing");
     
     if (timingNode != null)
     {
         if (timingNode.Attributes["href"] != null || timingNode.Attributes["id"] != null) 
         {
             if (timingNode.Attributes["id"] != null) 
             {
                 timingIDRef_ = timingNode.Attributes["id"].Value;
                 QuoteTiming ob = new QuoteTiming(timingNode);
                 IDManager.SetID(timingIDRef_, ob);
             }
             else if (timingNode.Attributes["href"] != null)
             {
                 timingIDRef_ = timingNode.Attributes["href"].Value;
             }
             else
             {
                 timing_ = new QuoteTiming(timingNode);
             }
         }
         else
         {
             timing_ = new QuoteTiming(timingNode);
         }
     }
     
 
     XmlNode businessCenterNode = xmlNode.SelectSingleNode("businessCenter");
     
     if (businessCenterNode != null)
     {
         if (businessCenterNode.Attributes["href"] != null || businessCenterNode.Attributes["id"] != null) 
         {
             if (businessCenterNode.Attributes["id"] != null) 
             {
                 businessCenterIDRef_ = businessCenterNode.Attributes["id"].Value;
                 BusinessCenter ob = new BusinessCenter(businessCenterNode);
                 IDManager.SetID(businessCenterIDRef_, ob);
             }
             else if (businessCenterNode.Attributes["href"] != null)
             {
                 businessCenterIDRef_ = businessCenterNode.Attributes["href"].Value;
             }
             else
             {
                 businessCenter_ = new BusinessCenter(businessCenterNode);
             }
         }
         else
         {
             businessCenter_ = new BusinessCenter(businessCenterNode);
         }
     }
     
 
     XmlNode exchangeIdNode = xmlNode.SelectSingleNode("exchangeId");
     
     if (exchangeIdNode != null)
     {
         if (exchangeIdNode.Attributes["href"] != null || exchangeIdNode.Attributes["id"] != null) 
         {
             if (exchangeIdNode.Attributes["id"] != null) 
             {
                 exchangeIdIDRef_ = exchangeIdNode.Attributes["id"].Value;
                 ExchangeId ob = new ExchangeId(exchangeIdNode);
                 IDManager.SetID(exchangeIdIDRef_, ob);
             }
             else if (exchangeIdNode.Attributes["href"] != null)
             {
                 exchangeIdIDRef_ = exchangeIdNode.Attributes["href"].Value;
             }
             else
             {
                 exchangeId_ = new ExchangeId(exchangeIdNode);
             }
         }
         else
         {
             exchangeId_ = new ExchangeId(exchangeIdNode);
         }
     }
     
 
     XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");
     
     if (informationSourceNodeList != null)
     {
         this.informationSource_ = new List<InformationSource>();
         foreach (XmlNode item in informationSourceNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     informationSourceIDRef_ = item.Attributes["id"].Value;
                     informationSource_.Add(new InformationSource(item));
                     IDManager.SetID(informationSourceIDRef_, informationSource_[informationSource_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     informationSourceIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 informationSource_.Add(new InformationSource(item));
                 }
             }
             else
             {
                 informationSource_.Add(new InformationSource(item));
             }
         }
     }
     
 
     XmlNode pricingModelNode = xmlNode.SelectSingleNode("pricingModel");
     
     if (pricingModelNode != null)
     {
         if (pricingModelNode.Attributes["href"] != null || pricingModelNode.Attributes["id"] != null) 
         {
             if (pricingModelNode.Attributes["id"] != null) 
             {
                 pricingModelIDRef_ = pricingModelNode.Attributes["id"].Value;
                 PricingModel ob = new PricingModel(pricingModelNode);
                 IDManager.SetID(pricingModelIDRef_, ob);
             }
             else if (pricingModelNode.Attributes["href"] != null)
             {
                 pricingModelIDRef_ = pricingModelNode.Attributes["href"].Value;
             }
             else
             {
                 pricingModel_ = new PricingModel(pricingModelNode);
             }
         }
         else
         {
             pricingModel_ = new PricingModel(pricingModelNode);
         }
     }
     
 
     XmlNode timeNode = xmlNode.SelectSingleNode("time");
     
     if (timeNode != null)
     {
         if (timeNode.Attributes["href"] != null || timeNode.Attributes["id"] != null) 
         {
             if (timeNode.Attributes["id"] != null) 
             {
                 timeIDRef_ = timeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(timeNode);
                 IDManager.SetID(timeIDRef_, ob);
             }
             else if (timeNode.Attributes["href"] != null)
             {
                 timeIDRef_ = timeNode.Attributes["href"].Value;
             }
             else
             {
                 time_ = new XsdTypeDateTime(timeNode);
             }
         }
         else
         {
             time_ = new XsdTypeDateTime(timeNode);
         }
     }
     
 
     XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");
     
     if (valuationDateNode != null)
     {
         if (valuationDateNode.Attributes["href"] != null || valuationDateNode.Attributes["id"] != null) 
         {
             if (valuationDateNode.Attributes["id"] != null) 
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["id"].Value;
                 XsdTypeDate ob = new XsdTypeDate(valuationDateNode);
                 IDManager.SetID(valuationDateIDRef_, ob);
             }
             else if (valuationDateNode.Attributes["href"] != null)
             {
                 valuationDateIDRef_ = valuationDateNode.Attributes["href"].Value;
             }
             else
             {
                 valuationDate_ = new XsdTypeDate(valuationDateNode);
             }
         }
         else
         {
             valuationDate_ = new XsdTypeDate(valuationDateNode);
         }
     }
     
 
     XmlNode expiryTimeNode = xmlNode.SelectSingleNode("expiryTime");
     
     if (expiryTimeNode != null)
     {
         if (expiryTimeNode.Attributes["href"] != null || expiryTimeNode.Attributes["id"] != null) 
         {
             if (expiryTimeNode.Attributes["id"] != null) 
             {
                 expiryTimeIDRef_ = expiryTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(expiryTimeNode);
                 IDManager.SetID(expiryTimeIDRef_, ob);
             }
             else if (expiryTimeNode.Attributes["href"] != null)
             {
                 expiryTimeIDRef_ = expiryTimeNode.Attributes["href"].Value;
             }
             else
             {
                 expiryTime_ = new XsdTypeDateTime(expiryTimeNode);
             }
         }
         else
         {
             expiryTime_ = new XsdTypeDateTime(expiryTimeNode);
         }
     }
     
 
     XmlNode cashflowTypeNode = xmlNode.SelectSingleNode("cashflowType");
     
     if (cashflowTypeNode != null)
     {
         if (cashflowTypeNode.Attributes["href"] != null || cashflowTypeNode.Attributes["id"] != null) 
         {
             if (cashflowTypeNode.Attributes["id"] != null) 
             {
                 cashflowTypeIDRef_ = cashflowTypeNode.Attributes["id"].Value;
                 CashflowType ob = new CashflowType(cashflowTypeNode);
                 IDManager.SetID(cashflowTypeIDRef_, ob);
             }
             else if (cashflowTypeNode.Attributes["href"] != null)
             {
                 cashflowTypeIDRef_ = cashflowTypeNode.Attributes["href"].Value;
             }
             else
             {
                 cashflowType_ = new CashflowType(cashflowTypeNode);
             }
         }
         else
         {
             cashflowType_ = new CashflowType(cashflowTypeNode);
         }
     }
     
 
 }
 public TradeProcessingTimestamps(XmlNode xmlNode)
 {
     XmlNode orderEnteredNode = xmlNode.SelectSingleNode("orderEntered");
     
     if (orderEnteredNode != null)
     {
         if (orderEnteredNode.Attributes["href"] != null || orderEnteredNode.Attributes["id"] != null) 
         {
             if (orderEnteredNode.Attributes["id"] != null) 
             {
                 orderEnteredIDRef_ = orderEnteredNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(orderEnteredNode);
                 IDManager.SetID(orderEnteredIDRef_, ob);
             }
             else if (orderEnteredNode.Attributes["href"] != null)
             {
                 orderEnteredIDRef_ = orderEnteredNode.Attributes["href"].Value;
             }
             else
             {
                 orderEntered_ = new XsdTypeDateTime(orderEnteredNode);
             }
         }
         else
         {
             orderEntered_ = new XsdTypeDateTime(orderEnteredNode);
         }
     }
     
 
     XmlNode orderSubmittedNode = xmlNode.SelectSingleNode("orderSubmitted");
     
     if (orderSubmittedNode != null)
     {
         if (orderSubmittedNode.Attributes["href"] != null || orderSubmittedNode.Attributes["id"] != null) 
         {
             if (orderSubmittedNode.Attributes["id"] != null) 
             {
                 orderSubmittedIDRef_ = orderSubmittedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(orderSubmittedNode);
                 IDManager.SetID(orderSubmittedIDRef_, ob);
             }
             else if (orderSubmittedNode.Attributes["href"] != null)
             {
                 orderSubmittedIDRef_ = orderSubmittedNode.Attributes["href"].Value;
             }
             else
             {
                 orderSubmitted_ = new XsdTypeDateTime(orderSubmittedNode);
             }
         }
         else
         {
             orderSubmitted_ = new XsdTypeDateTime(orderSubmittedNode);
         }
     }
     
 
     XmlNode publiclyReportedNode = xmlNode.SelectSingleNode("publiclyReported");
     
     if (publiclyReportedNode != null)
     {
         if (publiclyReportedNode.Attributes["href"] != null || publiclyReportedNode.Attributes["id"] != null) 
         {
             if (publiclyReportedNode.Attributes["id"] != null) 
             {
                 publiclyReportedIDRef_ = publiclyReportedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(publiclyReportedNode);
                 IDManager.SetID(publiclyReportedIDRef_, ob);
             }
             else if (publiclyReportedNode.Attributes["href"] != null)
             {
                 publiclyReportedIDRef_ = publiclyReportedNode.Attributes["href"].Value;
             }
             else
             {
                 publiclyReported_ = new XsdTypeDateTime(publiclyReportedNode);
             }
         }
         else
         {
             publiclyReported_ = new XsdTypeDateTime(publiclyReportedNode);
         }
     }
     
 
     XmlNode publicReportUpdatedNode = xmlNode.SelectSingleNode("publicReportUpdated");
     
     if (publicReportUpdatedNode != null)
     {
         if (publicReportUpdatedNode.Attributes["href"] != null || publicReportUpdatedNode.Attributes["id"] != null) 
         {
             if (publicReportUpdatedNode.Attributes["id"] != null) 
             {
                 publicReportUpdatedIDRef_ = publicReportUpdatedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(publicReportUpdatedNode);
                 IDManager.SetID(publicReportUpdatedIDRef_, ob);
             }
             else if (publicReportUpdatedNode.Attributes["href"] != null)
             {
                 publicReportUpdatedIDRef_ = publicReportUpdatedNode.Attributes["href"].Value;
             }
             else
             {
                 publicReportUpdated_ = new XsdTypeDateTime(publicReportUpdatedNode);
             }
         }
         else
         {
             publicReportUpdated_ = new XsdTypeDateTime(publicReportUpdatedNode);
         }
     }
     
 
     XmlNode nonpubliclyReportedNode = xmlNode.SelectSingleNode("nonpubliclyReported");
     
     if (nonpubliclyReportedNode != null)
     {
         if (nonpubliclyReportedNode.Attributes["href"] != null || nonpubliclyReportedNode.Attributes["id"] != null) 
         {
             if (nonpubliclyReportedNode.Attributes["id"] != null) 
             {
                 nonpubliclyReportedIDRef_ = nonpubliclyReportedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(nonpubliclyReportedNode);
                 IDManager.SetID(nonpubliclyReportedIDRef_, ob);
             }
             else if (nonpubliclyReportedNode.Attributes["href"] != null)
             {
                 nonpubliclyReportedIDRef_ = nonpubliclyReportedNode.Attributes["href"].Value;
             }
             else
             {
                 nonpubliclyReported_ = new XsdTypeDateTime(nonpubliclyReportedNode);
             }
         }
         else
         {
             nonpubliclyReported_ = new XsdTypeDateTime(nonpubliclyReportedNode);
         }
     }
     
 
     XmlNode nonpublicReportUpdatedNode = xmlNode.SelectSingleNode("nonpublicReportUpdated");
     
     if (nonpublicReportUpdatedNode != null)
     {
         if (nonpublicReportUpdatedNode.Attributes["href"] != null || nonpublicReportUpdatedNode.Attributes["id"] != null) 
         {
             if (nonpublicReportUpdatedNode.Attributes["id"] != null) 
             {
                 nonpublicReportUpdatedIDRef_ = nonpublicReportUpdatedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(nonpublicReportUpdatedNode);
                 IDManager.SetID(nonpublicReportUpdatedIDRef_, ob);
             }
             else if (nonpublicReportUpdatedNode.Attributes["href"] != null)
             {
                 nonpublicReportUpdatedIDRef_ = nonpublicReportUpdatedNode.Attributes["href"].Value;
             }
             else
             {
                 nonpublicReportUpdated_ = new XsdTypeDateTime(nonpublicReportUpdatedNode);
             }
         }
         else
         {
             nonpublicReportUpdated_ = new XsdTypeDateTime(nonpublicReportUpdatedNode);
         }
     }
     
 
     XmlNode submittedForConfirmationNode = xmlNode.SelectSingleNode("submittedForConfirmation");
     
     if (submittedForConfirmationNode != null)
     {
         if (submittedForConfirmationNode.Attributes["href"] != null || submittedForConfirmationNode.Attributes["id"] != null) 
         {
             if (submittedForConfirmationNode.Attributes["id"] != null) 
             {
                 submittedForConfirmationIDRef_ = submittedForConfirmationNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(submittedForConfirmationNode);
                 IDManager.SetID(submittedForConfirmationIDRef_, ob);
             }
             else if (submittedForConfirmationNode.Attributes["href"] != null)
             {
                 submittedForConfirmationIDRef_ = submittedForConfirmationNode.Attributes["href"].Value;
             }
             else
             {
                 submittedForConfirmation_ = new XsdTypeDateTime(submittedForConfirmationNode);
             }
         }
         else
         {
             submittedForConfirmation_ = new XsdTypeDateTime(submittedForConfirmationNode);
         }
     }
     
 
     XmlNode updatedForConfirmationNode = xmlNode.SelectSingleNode("updatedForConfirmation");
     
     if (updatedForConfirmationNode != null)
     {
         if (updatedForConfirmationNode.Attributes["href"] != null || updatedForConfirmationNode.Attributes["id"] != null) 
         {
             if (updatedForConfirmationNode.Attributes["id"] != null) 
             {
                 updatedForConfirmationIDRef_ = updatedForConfirmationNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(updatedForConfirmationNode);
                 IDManager.SetID(updatedForConfirmationIDRef_, ob);
             }
             else if (updatedForConfirmationNode.Attributes["href"] != null)
             {
                 updatedForConfirmationIDRef_ = updatedForConfirmationNode.Attributes["href"].Value;
             }
             else
             {
                 updatedForConfirmation_ = new XsdTypeDateTime(updatedForConfirmationNode);
             }
         }
         else
         {
             updatedForConfirmation_ = new XsdTypeDateTime(updatedForConfirmationNode);
         }
     }
     
 
     XmlNode confirmedNode = xmlNode.SelectSingleNode("confirmed");
     
     if (confirmedNode != null)
     {
         if (confirmedNode.Attributes["href"] != null || confirmedNode.Attributes["id"] != null) 
         {
             if (confirmedNode.Attributes["id"] != null) 
             {
                 confirmedIDRef_ = confirmedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(confirmedNode);
                 IDManager.SetID(confirmedIDRef_, ob);
             }
             else if (confirmedNode.Attributes["href"] != null)
             {
                 confirmedIDRef_ = confirmedNode.Attributes["href"].Value;
             }
             else
             {
                 confirmed_ = new XsdTypeDateTime(confirmedNode);
             }
         }
         else
         {
             confirmed_ = new XsdTypeDateTime(confirmedNode);
         }
     }
     
 
     XmlNode submittedForClearingNode = xmlNode.SelectSingleNode("submittedForClearing");
     
     if (submittedForClearingNode != null)
     {
         if (submittedForClearingNode.Attributes["href"] != null || submittedForClearingNode.Attributes["id"] != null) 
         {
             if (submittedForClearingNode.Attributes["id"] != null) 
             {
                 submittedForClearingIDRef_ = submittedForClearingNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(submittedForClearingNode);
                 IDManager.SetID(submittedForClearingIDRef_, ob);
             }
             else if (submittedForClearingNode.Attributes["href"] != null)
             {
                 submittedForClearingIDRef_ = submittedForClearingNode.Attributes["href"].Value;
             }
             else
             {
                 submittedForClearing_ = new XsdTypeDateTime(submittedForClearingNode);
             }
         }
         else
         {
             submittedForClearing_ = new XsdTypeDateTime(submittedForClearingNode);
         }
     }
     
 
     XmlNode updatedForClearingNode = xmlNode.SelectSingleNode("updatedForClearing");
     
     if (updatedForClearingNode != null)
     {
         if (updatedForClearingNode.Attributes["href"] != null || updatedForClearingNode.Attributes["id"] != null) 
         {
             if (updatedForClearingNode.Attributes["id"] != null) 
             {
                 updatedForClearingIDRef_ = updatedForClearingNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(updatedForClearingNode);
                 IDManager.SetID(updatedForClearingIDRef_, ob);
             }
             else if (updatedForClearingNode.Attributes["href"] != null)
             {
                 updatedForClearingIDRef_ = updatedForClearingNode.Attributes["href"].Value;
             }
             else
             {
                 updatedForClearing_ = new XsdTypeDateTime(updatedForClearingNode);
             }
         }
         else
         {
             updatedForClearing_ = new XsdTypeDateTime(updatedForClearingNode);
         }
     }
     
 
     XmlNode clearedNode = xmlNode.SelectSingleNode("cleared");
     
     if (clearedNode != null)
     {
         if (clearedNode.Attributes["href"] != null || clearedNode.Attributes["id"] != null) 
         {
             if (clearedNode.Attributes["id"] != null) 
             {
                 clearedIDRef_ = clearedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(clearedNode);
                 IDManager.SetID(clearedIDRef_, ob);
             }
             else if (clearedNode.Attributes["href"] != null)
             {
                 clearedIDRef_ = clearedNode.Attributes["href"].Value;
             }
             else
             {
                 cleared_ = new XsdTypeDateTime(clearedNode);
             }
         }
         else
         {
             cleared_ = new XsdTypeDateTime(clearedNode);
         }
     }
     
 
     XmlNode allocationsSubmittedNode = xmlNode.SelectSingleNode("allocationsSubmitted");
     
     if (allocationsSubmittedNode != null)
     {
         if (allocationsSubmittedNode.Attributes["href"] != null || allocationsSubmittedNode.Attributes["id"] != null) 
         {
             if (allocationsSubmittedNode.Attributes["id"] != null) 
             {
                 allocationsSubmittedIDRef_ = allocationsSubmittedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(allocationsSubmittedNode);
                 IDManager.SetID(allocationsSubmittedIDRef_, ob);
             }
             else if (allocationsSubmittedNode.Attributes["href"] != null)
             {
                 allocationsSubmittedIDRef_ = allocationsSubmittedNode.Attributes["href"].Value;
             }
             else
             {
                 allocationsSubmitted_ = new XsdTypeDateTime(allocationsSubmittedNode);
             }
         }
         else
         {
             allocationsSubmitted_ = new XsdTypeDateTime(allocationsSubmittedNode);
         }
     }
     
 
     XmlNode allocationsUpdatedNode = xmlNode.SelectSingleNode("allocationsUpdated");
     
     if (allocationsUpdatedNode != null)
     {
         if (allocationsUpdatedNode.Attributes["href"] != null || allocationsUpdatedNode.Attributes["id"] != null) 
         {
             if (allocationsUpdatedNode.Attributes["id"] != null) 
             {
                 allocationsUpdatedIDRef_ = allocationsUpdatedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(allocationsUpdatedNode);
                 IDManager.SetID(allocationsUpdatedIDRef_, ob);
             }
             else if (allocationsUpdatedNode.Attributes["href"] != null)
             {
                 allocationsUpdatedIDRef_ = allocationsUpdatedNode.Attributes["href"].Value;
             }
             else
             {
                 allocationsUpdated_ = new XsdTypeDateTime(allocationsUpdatedNode);
             }
         }
         else
         {
             allocationsUpdated_ = new XsdTypeDateTime(allocationsUpdatedNode);
         }
     }
     
 
     XmlNode allocationsCompletedNode = xmlNode.SelectSingleNode("allocationsCompleted");
     
     if (allocationsCompletedNode != null)
     {
         if (allocationsCompletedNode.Attributes["href"] != null || allocationsCompletedNode.Attributes["id"] != null) 
         {
             if (allocationsCompletedNode.Attributes["id"] != null) 
             {
                 allocationsCompletedIDRef_ = allocationsCompletedNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(allocationsCompletedNode);
                 IDManager.SetID(allocationsCompletedIDRef_, ob);
             }
             else if (allocationsCompletedNode.Attributes["href"] != null)
             {
                 allocationsCompletedIDRef_ = allocationsCompletedNode.Attributes["href"].Value;
             }
             else
             {
                 allocationsCompleted_ = new XsdTypeDateTime(allocationsCompletedNode);
             }
         }
         else
         {
             allocationsCompleted_ = new XsdTypeDateTime(allocationsCompletedNode);
         }
     }
     
 
     XmlNodeList timestampNodeList = xmlNode.SelectNodes("timestamp");
     
     if (timestampNodeList != null)
     {
         this.timestamp_ = new List<TradeTimestamp>();
         foreach (XmlNode item in timestampNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     timestampIDRef_ = item.Attributes["id"].Value;
                     timestamp_.Add(new TradeTimestamp(item));
                     IDManager.SetID(timestampIDRef_, timestamp_[timestamp_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     timestampIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 timestamp_.Add(new TradeTimestamp(item));
                 }
             }
             else
             {
                 timestamp_.Add(new TradeTimestamp(item));
             }
         }
     }
     
 
 }
        public TradeProcessingTimestamps(XmlNode xmlNode)
        {
            XmlNode orderEnteredNode = xmlNode.SelectSingleNode("orderEntered");

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


            XmlNode orderSubmittedNode = xmlNode.SelectSingleNode("orderSubmitted");

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


            XmlNode publiclyReportedNode = xmlNode.SelectSingleNode("publiclyReported");

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


            XmlNode publicReportUpdatedNode = xmlNode.SelectSingleNode("publicReportUpdated");

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


            XmlNode nonpubliclyReportedNode = xmlNode.SelectSingleNode("nonpubliclyReported");

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


            XmlNode nonpublicReportUpdatedNode = xmlNode.SelectSingleNode("nonpublicReportUpdated");

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


            XmlNode submittedForConfirmationNode = xmlNode.SelectSingleNode("submittedForConfirmation");

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


            XmlNode updatedForConfirmationNode = xmlNode.SelectSingleNode("updatedForConfirmation");

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


            XmlNode confirmedNode = xmlNode.SelectSingleNode("confirmed");

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


            XmlNode submittedForClearingNode = xmlNode.SelectSingleNode("submittedForClearing");

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


            XmlNode updatedForClearingNode = xmlNode.SelectSingleNode("updatedForClearing");

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


            XmlNode clearedNode = xmlNode.SelectSingleNode("cleared");

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


            XmlNode allocationsSubmittedNode = xmlNode.SelectSingleNode("allocationsSubmitted");

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


            XmlNode allocationsUpdatedNode = xmlNode.SelectSingleNode("allocationsUpdated");

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


            XmlNode allocationsCompletedNode = xmlNode.SelectSingleNode("allocationsCompleted");

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


            XmlNodeList timestampNodeList = xmlNode.SelectNodes("timestamp");

            if (timestampNodeList != null)
            {
                this.timestamp_ = new List <TradeTimestamp>();
                foreach (XmlNode item in timestampNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            timestampIDRef_ = item.Attributes["id"].Value;
                            timestamp_.Add(new TradeTimestamp(item));
                            IDManager.SetID(timestampIDRef_, timestamp_[timestamp_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            timestampIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            timestamp_.Add(new TradeTimestamp(item));
                        }
                    }
                    else
                    {
                        timestamp_.Add(new TradeTimestamp(item));
                    }
                }
            }
        }
 public PricingStructureValuation(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode baseDateNode = xmlNode.SelectSingleNode("baseDate");
     
     if (baseDateNode != null)
     {
         if (baseDateNode.Attributes["href"] != null || baseDateNode.Attributes["id"] != null) 
         {
             if (baseDateNode.Attributes["id"] != null) 
             {
                 baseDateIDRef_ = baseDateNode.Attributes["id"].Value;
                 IdentifiedDate ob = new IdentifiedDate(baseDateNode);
                 IDManager.SetID(baseDateIDRef_, ob);
             }
             else if (baseDateNode.Attributes["href"] != null)
             {
                 baseDateIDRef_ = baseDateNode.Attributes["href"].Value;
             }
             else
             {
                 baseDate_ = new IdentifiedDate(baseDateNode);
             }
         }
         else
         {
             baseDate_ = new IdentifiedDate(baseDateNode);
         }
     }
     
 
     XmlNode spotDateNode = xmlNode.SelectSingleNode("spotDate");
     
     if (spotDateNode != null)
     {
         if (spotDateNode.Attributes["href"] != null || spotDateNode.Attributes["id"] != null) 
         {
             if (spotDateNode.Attributes["id"] != null) 
             {
                 spotDateIDRef_ = spotDateNode.Attributes["id"].Value;
                 IdentifiedDate ob = new IdentifiedDate(spotDateNode);
                 IDManager.SetID(spotDateIDRef_, ob);
             }
             else if (spotDateNode.Attributes["href"] != null)
             {
                 spotDateIDRef_ = spotDateNode.Attributes["href"].Value;
             }
             else
             {
                 spotDate_ = new IdentifiedDate(spotDateNode);
             }
         }
         else
         {
             spotDate_ = new IdentifiedDate(spotDateNode);
         }
     }
     
 
     XmlNode inputDataDateNode = xmlNode.SelectSingleNode("inputDataDate");
     
     if (inputDataDateNode != null)
     {
         if (inputDataDateNode.Attributes["href"] != null || inputDataDateNode.Attributes["id"] != null) 
         {
             if (inputDataDateNode.Attributes["id"] != null) 
             {
                 inputDataDateIDRef_ = inputDataDateNode.Attributes["id"].Value;
                 IdentifiedDate ob = new IdentifiedDate(inputDataDateNode);
                 IDManager.SetID(inputDataDateIDRef_, ob);
             }
             else if (inputDataDateNode.Attributes["href"] != null)
             {
                 inputDataDateIDRef_ = inputDataDateNode.Attributes["href"].Value;
             }
             else
             {
                 inputDataDate_ = new IdentifiedDate(inputDataDateNode);
             }
         }
         else
         {
             inputDataDate_ = new IdentifiedDate(inputDataDateNode);
         }
     }
     
 
     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;
                 IdentifiedDate ob = new IdentifiedDate(endDateNode);
                 IDManager.SetID(endDateIDRef_, ob);
             }
             else if (endDateNode.Attributes["href"] != null)
             {
                 endDateIDRef_ = endDateNode.Attributes["href"].Value;
             }
             else
             {
                 endDate_ = new IdentifiedDate(endDateNode);
             }
         }
         else
         {
             endDate_ = new IdentifiedDate(endDateNode);
         }
     }
     
 
     XmlNode buildDateTimeNode = xmlNode.SelectSingleNode("buildDateTime");
     
     if (buildDateTimeNode != null)
     {
         if (buildDateTimeNode.Attributes["href"] != null || buildDateTimeNode.Attributes["id"] != null) 
         {
             if (buildDateTimeNode.Attributes["id"] != null) 
             {
                 buildDateTimeIDRef_ = buildDateTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(buildDateTimeNode);
                 IDManager.SetID(buildDateTimeIDRef_, ob);
             }
             else if (buildDateTimeNode.Attributes["href"] != null)
             {
                 buildDateTimeIDRef_ = buildDateTimeNode.Attributes["href"].Value;
             }
             else
             {
                 buildDateTime_ = new XsdTypeDateTime(buildDateTimeNode);
             }
         }
         else
         {
             buildDateTime_ = new XsdTypeDateTime(buildDateTimeNode);
         }
     }
     
 
 }
        public ServiceAdvisory(XmlNode xmlNode)
        {
            XmlNode categoryNode = xmlNode.SelectSingleNode("category");

            if (categoryNode != null)
            {
                if (categoryNode.Attributes["href"] != null || categoryNode.Attributes["id"] != null)
                {
                    if (categoryNode.Attributes["id"] != null)
                    {
                        categoryIDRef_ = categoryNode.Attributes["id"].Value;
                        ServiceAdvisoryCategory ob = new ServiceAdvisoryCategory(categoryNode);
                        IDManager.SetID(categoryIDRef_, ob);
                    }
                    else if (categoryNode.Attributes["href"] != null)
                    {
                        categoryIDRef_ = categoryNode.Attributes["href"].Value;
                    }
                    else
                    {
                        category_ = new ServiceAdvisoryCategory(categoryNode);
                    }
                }
                else
                {
                    category_ = new ServiceAdvisoryCategory(categoryNode);
                }
            }


            XmlNode descriptionNode = xmlNode.SelectSingleNode("description");

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


            XmlNode effectiveFromNode = xmlNode.SelectSingleNode("effectiveFrom");

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


            XmlNode effectiveToNode = xmlNode.SelectSingleNode("effectiveTo");

            if (effectiveToNode != null)
            {
                if (effectiveToNode.Attributes["href"] != null || effectiveToNode.Attributes["id"] != null)
                {
                    if (effectiveToNode.Attributes["id"] != null)
                    {
                        effectiveToIDRef_ = effectiveToNode.Attributes["id"].Value;
                        XsdTypeDateTime ob = new XsdTypeDateTime(effectiveToNode);
                        IDManager.SetID(effectiveToIDRef_, ob);
                    }
                    else if (effectiveToNode.Attributes["href"] != null)
                    {
                        effectiveToIDRef_ = effectiveToNode.Attributes["href"].Value;
                    }
                    else
                    {
                        effectiveTo_ = new XsdTypeDateTime(effectiveToNode);
                    }
                }
                else
                {
                    effectiveTo_ = new XsdTypeDateTime(effectiveToNode);
                }
            }
        }
 public ServiceAdvisory(XmlNode xmlNode)
 {
     XmlNode categoryNode = xmlNode.SelectSingleNode("category");
     
     if (categoryNode != null)
     {
         if (categoryNode.Attributes["href"] != null || categoryNode.Attributes["id"] != null) 
         {
             if (categoryNode.Attributes["id"] != null) 
             {
                 categoryIDRef_ = categoryNode.Attributes["id"].Value;
                 ServiceAdvisoryCategory ob = new ServiceAdvisoryCategory(categoryNode);
                 IDManager.SetID(categoryIDRef_, ob);
             }
             else if (categoryNode.Attributes["href"] != null)
             {
                 categoryIDRef_ = categoryNode.Attributes["href"].Value;
             }
             else
             {
                 category_ = new ServiceAdvisoryCategory(categoryNode);
             }
         }
         else
         {
             category_ = new ServiceAdvisoryCategory(categoryNode);
         }
     }
     
 
     XmlNode descriptionNode = xmlNode.SelectSingleNode("description");
     
     if (descriptionNode != null)
     {
         if (descriptionNode.Attributes["href"] != null || descriptionNode.Attributes["id"] != null) 
         {
             if (descriptionNode.Attributes["id"] != null) 
             {
                 descriptionIDRef_ = descriptionNode.Attributes["id"].Value;
                 XsdTypeString ob = new XsdTypeString(descriptionNode);
                 IDManager.SetID(descriptionIDRef_, ob);
             }
             else if (descriptionNode.Attributes["href"] != null)
             {
                 descriptionIDRef_ = descriptionNode.Attributes["href"].Value;
             }
             else
             {
                 description_ = new XsdTypeString(descriptionNode);
             }
         }
         else
         {
             description_ = new XsdTypeString(descriptionNode);
         }
     }
     
 
     XmlNode effectiveFromNode = xmlNode.SelectSingleNode("effectiveFrom");
     
     if (effectiveFromNode != null)
     {
         if (effectiveFromNode.Attributes["href"] != null || effectiveFromNode.Attributes["id"] != null) 
         {
             if (effectiveFromNode.Attributes["id"] != null) 
             {
                 effectiveFromIDRef_ = effectiveFromNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(effectiveFromNode);
                 IDManager.SetID(effectiveFromIDRef_, ob);
             }
             else if (effectiveFromNode.Attributes["href"] != null)
             {
                 effectiveFromIDRef_ = effectiveFromNode.Attributes["href"].Value;
             }
             else
             {
                 effectiveFrom_ = new XsdTypeDateTime(effectiveFromNode);
             }
         }
         else
         {
             effectiveFrom_ = new XsdTypeDateTime(effectiveFromNode);
         }
     }
     
 
     XmlNode effectiveToNode = xmlNode.SelectSingleNode("effectiveTo");
     
     if (effectiveToNode != null)
     {
         if (effectiveToNode.Attributes["href"] != null || effectiveToNode.Attributes["id"] != null) 
         {
             if (effectiveToNode.Attributes["id"] != null) 
             {
                 effectiveToIDRef_ = effectiveToNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(effectiveToNode);
                 IDManager.SetID(effectiveToIDRef_, ob);
             }
             else if (effectiveToNode.Attributes["href"] != null)
             {
                 effectiveToIDRef_ = effectiveToNode.Attributes["href"].Value;
             }
             else
             {
                 effectiveTo_ = new XsdTypeDateTime(effectiveToNode);
             }
         }
         else
         {
             effectiveTo_ = new XsdTypeDateTime(effectiveToNode);
         }
     }
     
 
 }
示例#17
0
        public TradeProcessingTimestamps(XmlNode xmlNode)
        {
            XmlNodeList orderEnteredNodeList = xmlNode.SelectNodes("orderEntered");

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

            foreach (XmlNode item in orderEnteredNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        orderEnteredIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(orderEnteredIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        orderEnteredIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        orderEntered = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList orderSubmittedNodeList = xmlNode.SelectNodes("orderSubmitted");

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

            foreach (XmlNode item in orderSubmittedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        orderSubmittedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(orderSubmittedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        orderSubmittedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        orderSubmitted = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList publiclyReportedNodeList = xmlNode.SelectNodes("publiclyReported");

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

            foreach (XmlNode item in publiclyReportedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        publiclyReportedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(publiclyReportedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        publiclyReportedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        publiclyReported = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList publicReportUpdatedNodeList = xmlNode.SelectNodes("publicReportUpdated");

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

            foreach (XmlNode item in publicReportUpdatedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        publicReportUpdatedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(publicReportUpdatedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        publicReportUpdatedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        publicReportUpdated = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList nonpubliclyReportedNodeList = xmlNode.SelectNodes("nonpubliclyReported");

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

            foreach (XmlNode item in nonpubliclyReportedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        nonpubliclyReportedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(nonpubliclyReportedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        nonpubliclyReportedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        nonpubliclyReported = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList nonpublicReportUpdatedNodeList = xmlNode.SelectNodes("nonpublicReportUpdated");

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

            foreach (XmlNode item in nonpublicReportUpdatedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        nonpublicReportUpdatedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(nonpublicReportUpdatedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        nonpublicReportUpdatedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        nonpublicReportUpdated = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList submittedForConfirmationNodeList = xmlNode.SelectNodes("submittedForConfirmation");

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

            foreach (XmlNode item in submittedForConfirmationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        submittedForConfirmationIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(submittedForConfirmationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        submittedForConfirmationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        submittedForConfirmation = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList updatedForConfirmationNodeList = xmlNode.SelectNodes("updatedForConfirmation");

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

            foreach (XmlNode item in updatedForConfirmationNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        updatedForConfirmationIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(updatedForConfirmationIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        updatedForConfirmationIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        updatedForConfirmation = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList confirmedNodeList = xmlNode.SelectNodes("confirmed");

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

            foreach (XmlNode item in confirmedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        confirmedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(confirmedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        confirmedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        confirmed = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList submittedForClearingNodeList = xmlNode.SelectNodes("submittedForClearing");

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

            foreach (XmlNode item in submittedForClearingNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        submittedForClearingIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(submittedForClearingIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        submittedForClearingIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        submittedForClearing = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList updatedForClearingNodeList = xmlNode.SelectNodes("updatedForClearing");

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

            foreach (XmlNode item in updatedForClearingNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        updatedForClearingIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(updatedForClearingIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        updatedForClearingIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        updatedForClearing = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList clearedNodeList = xmlNode.SelectNodes("cleared");

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

            foreach (XmlNode item in clearedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        clearedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(clearedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        clearedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cleared = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList allocationsSubmittedNodeList = xmlNode.SelectNodes("allocationsSubmitted");

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

            foreach (XmlNode item in allocationsSubmittedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        allocationsSubmittedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(allocationsSubmittedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        allocationsSubmittedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        allocationsSubmitted = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList allocationsUpdatedNodeList = xmlNode.SelectNodes("allocationsUpdated");

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

            foreach (XmlNode item in allocationsUpdatedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        allocationsUpdatedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(allocationsUpdatedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        allocationsUpdatedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        allocationsUpdated = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList allocationsCompletedNodeList = xmlNode.SelectNodes("allocationsCompleted");

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

            foreach (XmlNode item in allocationsCompletedNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        allocationsCompletedIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(allocationsCompletedIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        allocationsCompletedIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        allocationsCompleted = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList timestampNodeList = xmlNode.SelectNodes("timestamp");

            foreach (XmlNode item in timestampNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        timestampIDRef = item.Attributes["id"].Name;
                        List <TradeTimestamp> ob = new List <TradeTimestamp>();
                        ob.Add(new TradeTimestamp(item));
                        IDManager.SetID(timestampIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        timestampIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        timestamp.Add(new TradeTimestamp(item));
                    }
                }
            }
        }
 public WeightedAveragingObservation(XmlNode xmlNode)
 {
     XmlNode dateTimeNode = xmlNode.SelectSingleNode("dateTime");
     
     if (dateTimeNode != null)
     {
         if (dateTimeNode.Attributes["href"] != null || dateTimeNode.Attributes["id"] != null) 
         {
             if (dateTimeNode.Attributes["id"] != null) 
             {
                 dateTimeIDRef_ = dateTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(dateTimeNode);
                 IDManager.SetID(dateTimeIDRef_, ob);
             }
             else if (dateTimeNode.Attributes["href"] != null)
             {
                 dateTimeIDRef_ = dateTimeNode.Attributes["href"].Value;
             }
             else
             {
                 dateTime_ = new XsdTypeDateTime(dateTimeNode);
             }
         }
         else
         {
             dateTime_ = new XsdTypeDateTime(dateTimeNode);
         }
     }
     
 
     XmlNode observationNumberNode = xmlNode.SelectSingleNode("observationNumber");
     
     if (observationNumberNode != null)
     {
         if (observationNumberNode.Attributes["href"] != null || observationNumberNode.Attributes["id"] != null) 
         {
             if (observationNumberNode.Attributes["id"] != null) 
             {
                 observationNumberIDRef_ = observationNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(observationNumberNode);
                 IDManager.SetID(observationNumberIDRef_, ob);
             }
             else if (observationNumberNode.Attributes["href"] != null)
             {
                 observationNumberIDRef_ = observationNumberNode.Attributes["href"].Value;
             }
             else
             {
                 observationNumber_ = new XsdTypePositiveInteger(observationNumberNode);
             }
         }
         else
         {
             observationNumber_ = new XsdTypePositiveInteger(observationNumberNode);
         }
     }
     
 
     XmlNode weightNode = xmlNode.SelectSingleNode("weight");
     
     if (weightNode != null)
     {
         if (weightNode.Attributes["href"] != null || weightNode.Attributes["id"] != null) 
         {
             if (weightNode.Attributes["id"] != null) 
             {
                 weightIDRef_ = weightNode.Attributes["id"].Value;
                 NonNegativeDecimal ob = new NonNegativeDecimal(weightNode);
                 IDManager.SetID(weightIDRef_, ob);
             }
             else if (weightNode.Attributes["href"] != null)
             {
                 weightIDRef_ = weightNode.Attributes["href"].Value;
             }
             else
             {
                 weight_ = new NonNegativeDecimal(weightNode);
             }
         }
         else
         {
             weight_ = new NonNegativeDecimal(weightNode);
         }
     }
     
 
 }
        public QuotationCharacteristics(XmlNode xmlNode)
        {
            XmlNodeList measureTypeNodeList = xmlNode.SelectNodes("measureType");

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

            foreach (XmlNode item in measureTypeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        measureTypeIDRef = item.Attributes["id"].Name;
                        AssetMeasureType ob = AssetMeasureType();
                        IDManager.SetID(measureTypeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        measureTypeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        measureType = new AssetMeasureType(item);
                    }
                }
            }


            XmlNodeList quoteUnitsNodeList = xmlNode.SelectNodes("quoteUnits");

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

            foreach (XmlNode item in quoteUnitsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        quoteUnitsIDRef = item.Attributes["id"].Name;
                        PriceQuoteUnits ob = PriceQuoteUnits();
                        IDManager.SetID(quoteUnitsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        quoteUnitsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        quoteUnits = new PriceQuoteUnits(item);
                    }
                }
            }


            XmlNodeList sideNodeList = xmlNode.SelectNodes("side");

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

            foreach (XmlNode item in sideNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        sideIDRef = item.Attributes["id"].Name;
                        QuotationSideEnum ob = QuotationSideEnum();
                        IDManager.SetID(sideIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        sideIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        side = new QuotationSideEnum(item);
                    }
                }
            }


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

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

            foreach (XmlNode item in currencyNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        currencyIDRef = item.Attributes["id"].Name;
                        Currency ob = Currency();
                        IDManager.SetID(currencyIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        currencyIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        currency = new Currency(item);
                    }
                }
            }


            XmlNodeList currencyTypeNodeList = xmlNode.SelectNodes("currencyType");

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

            foreach (XmlNode item in currencyTypeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        currencyTypeIDRef = item.Attributes["id"].Name;
                        ReportingCurrencyType ob = ReportingCurrencyType();
                        IDManager.SetID(currencyTypeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        currencyTypeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        currencyType = new ReportingCurrencyType(item);
                    }
                }
            }


            XmlNodeList timingNodeList = xmlNode.SelectNodes("timing");

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

            foreach (XmlNode item in timingNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        timingIDRef = item.Attributes["id"].Name;
                        QuoteTiming ob = QuoteTiming();
                        IDManager.SetID(timingIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        timingIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        timing = new QuoteTiming(item);
                    }
                }
            }


            XmlNodeList businessCenterNodeList = xmlNode.SelectNodes("businessCenter");

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

            foreach (XmlNode item in businessCenterNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        businessCenterIDRef = item.Attributes["id"].Name;
                        BusinessCenter ob = BusinessCenter();
                        IDManager.SetID(businessCenterIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        businessCenterIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        businessCenter = new BusinessCenter(item);
                    }
                }
            }


            XmlNodeList exchangeIdNodeList = xmlNode.SelectNodes("exchangeId");

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

            foreach (XmlNode item in exchangeIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        exchangeIdIDRef = item.Attributes["id"].Name;
                        ExchangeId ob = ExchangeId();
                        IDManager.SetID(exchangeIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        exchangeIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        exchangeId = new ExchangeId(item);
                    }
                }
            }


            XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");

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


            XmlNodeList pricingModelNodeList = xmlNode.SelectNodes("pricingModel");

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

            foreach (XmlNode item in pricingModelNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        pricingModelIDRef = item.Attributes["id"].Name;
                        PricingModel ob = PricingModel();
                        IDManager.SetID(pricingModelIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        pricingModelIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        pricingModel = new PricingModel(item);
                    }
                }
            }


            XmlNodeList timeNodeList = xmlNode.SelectNodes("time");

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

            foreach (XmlNode item in timeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        timeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(timeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        timeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        time = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList valuationDateNodeList = xmlNode.SelectNodes("valuationDate");

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

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


            XmlNodeList expiryTimeNodeList = xmlNode.SelectNodes("expiryTime");

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

            foreach (XmlNode item in expiryTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        expiryTimeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(expiryTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        expiryTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        expiryTime = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList cashflowTypeNodeList = xmlNode.SelectNodes("cashflowType");

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

            foreach (XmlNode item in cashflowTypeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        cashflowTypeIDRef = item.Attributes["id"].Name;
                        CashflowType ob = CashflowType();
                        IDManager.SetID(cashflowTypeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        cashflowTypeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        cashflowType = new CashflowType(item);
                    }
                }
            }
        }
 public ClearingStatusItem(XmlNode xmlNode)
 {
     XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");
     
     if (tradeIdentifierNodeList != null)
     {
         this.tradeIdentifier_ = new List<TradeIdentifier>();
         foreach (XmlNode item in tradeIdentifierNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     tradeIdentifierIDRef_ = item.Attributes["id"].Value;
                     tradeIdentifier_.Add(new TradeIdentifier(item));
                     IDManager.SetID(tradeIdentifierIDRef_, tradeIdentifier_[tradeIdentifier_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     tradeIdentifierIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 tradeIdentifier_.Add(new TradeIdentifier(item));
                 }
             }
             else
             {
                 tradeIdentifier_.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNode tradeReferenceInformationNode = xmlNode.SelectSingleNode("tradeReferenceInformation");
     
     if (tradeReferenceInformationNode != null)
     {
         if (tradeReferenceInformationNode.Attributes["href"] != null || tradeReferenceInformationNode.Attributes["id"] != null) 
         {
             if (tradeReferenceInformationNode.Attributes["id"] != null) 
             {
                 tradeReferenceInformationIDRef_ = tradeReferenceInformationNode.Attributes["id"].Value;
                 TradeReferenceInformation ob = new TradeReferenceInformation(tradeReferenceInformationNode);
                 IDManager.SetID(tradeReferenceInformationIDRef_, ob);
             }
             else if (tradeReferenceInformationNode.Attributes["href"] != null)
             {
                 tradeReferenceInformationIDRef_ = tradeReferenceInformationNode.Attributes["href"].Value;
             }
             else
             {
                 tradeReferenceInformation_ = new TradeReferenceInformation(tradeReferenceInformationNode);
             }
         }
         else
         {
             tradeReferenceInformation_ = new TradeReferenceInformation(tradeReferenceInformationNode);
         }
     }
     
 
     XmlNode tradeNode = xmlNode.SelectSingleNode("trade");
     
     if (tradeNode != null)
     {
         if (tradeNode.Attributes["href"] != null || tradeNode.Attributes["id"] != null) 
         {
             if (tradeNode.Attributes["id"] != null) 
             {
                 tradeIDRef_ = tradeNode.Attributes["id"].Value;
                 Trade ob = new Trade(tradeNode);
                 IDManager.SetID(tradeIDRef_, ob);
             }
             else if (tradeNode.Attributes["href"] != null)
             {
                 tradeIDRef_ = tradeNode.Attributes["href"].Value;
             }
             else
             {
                 trade_ = new Trade(tradeNode);
             }
         }
         else
         {
             trade_ = new Trade(tradeNode);
         }
     }
     
 
     XmlNode clearingStatusValueNode = xmlNode.SelectSingleNode("clearingStatusValue");
     
     if (clearingStatusValueNode != null)
     {
         if (clearingStatusValueNode.Attributes["href"] != null || clearingStatusValueNode.Attributes["id"] != null) 
         {
             if (clearingStatusValueNode.Attributes["id"] != null) 
             {
                 clearingStatusValueIDRef_ = clearingStatusValueNode.Attributes["id"].Value;
                 ClearingStatusValue ob = new ClearingStatusValue(clearingStatusValueNode);
                 IDManager.SetID(clearingStatusValueIDRef_, ob);
             }
             else if (clearingStatusValueNode.Attributes["href"] != null)
             {
                 clearingStatusValueIDRef_ = clearingStatusValueNode.Attributes["href"].Value;
             }
             else
             {
                 clearingStatusValue_ = new ClearingStatusValue(clearingStatusValueNode);
             }
         }
         else
         {
             clearingStatusValue_ = new ClearingStatusValue(clearingStatusValueNode);
         }
     }
     
 
     XmlNode updatedDateTimeNode = xmlNode.SelectSingleNode("updatedDateTime");
     
     if (updatedDateTimeNode != null)
     {
         if (updatedDateTimeNode.Attributes["href"] != null || updatedDateTimeNode.Attributes["id"] != null) 
         {
             if (updatedDateTimeNode.Attributes["id"] != null) 
             {
                 updatedDateTimeIDRef_ = updatedDateTimeNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(updatedDateTimeNode);
                 IDManager.SetID(updatedDateTimeIDRef_, ob);
             }
             else if (updatedDateTimeNode.Attributes["href"] != null)
             {
                 updatedDateTimeIDRef_ = updatedDateTimeNode.Attributes["href"].Value;
             }
             else
             {
                 updatedDateTime_ = new XsdTypeDateTime(updatedDateTimeNode);
             }
         }
         else
         {
             updatedDateTime_ = new XsdTypeDateTime(updatedDateTimeNode);
         }
     }
     
 
     XmlNodeList reasonNodeList = xmlNode.SelectNodes("reason");
     
     if (reasonNodeList != null)
     {
         this.reason_ = new List<Reason>();
         foreach (XmlNode item in reasonNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     reasonIDRef_ = item.Attributes["id"].Value;
                     reason_.Add(new Reason(item));
                     IDManager.SetID(reasonIDRef_, reason_[reason_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     reasonIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 reason_.Add(new Reason(item));
                 }
             }
             else
             {
                 reason_.Add(new Reason(item));
             }
         }
     }
     
 
     XmlNodeList statusAppliesToNodeList = xmlNode.SelectNodes("statusAppliesTo");
     
     if (statusAppliesToNodeList != null)
     {
         this.statusAppliesTo_ = new List<PartyReference>();
         foreach (XmlNode item in statusAppliesToNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     statusAppliesToIDRef_ = item.Attributes["id"].Value;
                     statusAppliesTo_.Add(new PartyReference(item));
                     IDManager.SetID(statusAppliesToIDRef_, statusAppliesTo_[statusAppliesTo_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     statusAppliesToIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 statusAppliesTo_.Add(new PartyReference(item));
                 }
             }
             else
             {
                 statusAppliesTo_.Add(new PartyReference(item));
             }
         }
     }
     
 
 }
示例#21
0
        public MultiDimensionalPricingData(XmlNode xmlNode)
        {
            XmlNode measureTypeNode = xmlNode.SelectSingleNode("measureType");

            if (measureTypeNode != null)
            {
                if (measureTypeNode.Attributes["href"] != null || measureTypeNode.Attributes["id"] != null)
                {
                    if (measureTypeNode.Attributes["id"] != null)
                    {
                        measureTypeIDRef_ = measureTypeNode.Attributes["id"].Value;
                        AssetMeasureType ob = new AssetMeasureType(measureTypeNode);
                        IDManager.SetID(measureTypeIDRef_, ob);
                    }
                    else if (measureTypeNode.Attributes["href"] != null)
                    {
                        measureTypeIDRef_ = measureTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        measureType_ = new AssetMeasureType(measureTypeNode);
                    }
                }
                else
                {
                    measureType_ = new AssetMeasureType(measureTypeNode);
                }
            }


            XmlNode quoteUnitsNode = xmlNode.SelectSingleNode("quoteUnits");

            if (quoteUnitsNode != null)
            {
                if (quoteUnitsNode.Attributes["href"] != null || quoteUnitsNode.Attributes["id"] != null)
                {
                    if (quoteUnitsNode.Attributes["id"] != null)
                    {
                        quoteUnitsIDRef_ = quoteUnitsNode.Attributes["id"].Value;
                        PriceQuoteUnits ob = new PriceQuoteUnits(quoteUnitsNode);
                        IDManager.SetID(quoteUnitsIDRef_, ob);
                    }
                    else if (quoteUnitsNode.Attributes["href"] != null)
                    {
                        quoteUnitsIDRef_ = quoteUnitsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
                    }
                }
                else
                {
                    quoteUnits_ = new PriceQuoteUnits(quoteUnitsNode);
                }
            }


            XmlNode sideNode = xmlNode.SelectSingleNode("side");

            if (sideNode != null)
            {
                if (sideNode.Attributes["href"] != null || sideNode.Attributes["id"] != null)
                {
                    if (sideNode.Attributes["id"] != null)
                    {
                        sideIDRef_ = sideNode.Attributes["id"].Value;
                        QuotationSideEnum ob = new QuotationSideEnum(sideNode);
                        IDManager.SetID(sideIDRef_, ob);
                    }
                    else if (sideNode.Attributes["href"] != null)
                    {
                        sideIDRef_ = sideNode.Attributes["href"].Value;
                    }
                    else
                    {
                        side_ = new QuotationSideEnum(sideNode);
                    }
                }
                else
                {
                    side_ = new QuotationSideEnum(sideNode);
                }
            }


            XmlNode currencyNode = xmlNode.SelectSingleNode("currency");

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


            XmlNode currencyTypeNode = xmlNode.SelectSingleNode("currencyType");

            if (currencyTypeNode != null)
            {
                if (currencyTypeNode.Attributes["href"] != null || currencyTypeNode.Attributes["id"] != null)
                {
                    if (currencyTypeNode.Attributes["id"] != null)
                    {
                        currencyTypeIDRef_ = currencyTypeNode.Attributes["id"].Value;
                        ReportingCurrencyType ob = new ReportingCurrencyType(currencyTypeNode);
                        IDManager.SetID(currencyTypeIDRef_, ob);
                    }
                    else if (currencyTypeNode.Attributes["href"] != null)
                    {
                        currencyTypeIDRef_ = currencyTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        currencyType_ = new ReportingCurrencyType(currencyTypeNode);
                    }
                }
                else
                {
                    currencyType_ = new ReportingCurrencyType(currencyTypeNode);
                }
            }


            XmlNode timingNode = xmlNode.SelectSingleNode("timing");

            if (timingNode != null)
            {
                if (timingNode.Attributes["href"] != null || timingNode.Attributes["id"] != null)
                {
                    if (timingNode.Attributes["id"] != null)
                    {
                        timingIDRef_ = timingNode.Attributes["id"].Value;
                        QuoteTiming ob = new QuoteTiming(timingNode);
                        IDManager.SetID(timingIDRef_, ob);
                    }
                    else if (timingNode.Attributes["href"] != null)
                    {
                        timingIDRef_ = timingNode.Attributes["href"].Value;
                    }
                    else
                    {
                        timing_ = new QuoteTiming(timingNode);
                    }
                }
                else
                {
                    timing_ = new QuoteTiming(timingNode);
                }
            }


            XmlNode businessCenterNode = xmlNode.SelectSingleNode("businessCenter");

            if (businessCenterNode != null)
            {
                if (businessCenterNode.Attributes["href"] != null || businessCenterNode.Attributes["id"] != null)
                {
                    if (businessCenterNode.Attributes["id"] != null)
                    {
                        businessCenterIDRef_ = businessCenterNode.Attributes["id"].Value;
                        BusinessCenter ob = new BusinessCenter(businessCenterNode);
                        IDManager.SetID(businessCenterIDRef_, ob);
                    }
                    else if (businessCenterNode.Attributes["href"] != null)
                    {
                        businessCenterIDRef_ = businessCenterNode.Attributes["href"].Value;
                    }
                    else
                    {
                        businessCenter_ = new BusinessCenter(businessCenterNode);
                    }
                }
                else
                {
                    businessCenter_ = new BusinessCenter(businessCenterNode);
                }
            }


            XmlNode exchangeIdNode = xmlNode.SelectSingleNode("exchangeId");

            if (exchangeIdNode != null)
            {
                if (exchangeIdNode.Attributes["href"] != null || exchangeIdNode.Attributes["id"] != null)
                {
                    if (exchangeIdNode.Attributes["id"] != null)
                    {
                        exchangeIdIDRef_ = exchangeIdNode.Attributes["id"].Value;
                        ExchangeId ob = new ExchangeId(exchangeIdNode);
                        IDManager.SetID(exchangeIdIDRef_, ob);
                    }
                    else if (exchangeIdNode.Attributes["href"] != null)
                    {
                        exchangeIdIDRef_ = exchangeIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        exchangeId_ = new ExchangeId(exchangeIdNode);
                    }
                }
                else
                {
                    exchangeId_ = new ExchangeId(exchangeIdNode);
                }
            }


            XmlNodeList informationSourceNodeList = xmlNode.SelectNodes("informationSource");

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


            XmlNode pricingModelNode = xmlNode.SelectSingleNode("pricingModel");

            if (pricingModelNode != null)
            {
                if (pricingModelNode.Attributes["href"] != null || pricingModelNode.Attributes["id"] != null)
                {
                    if (pricingModelNode.Attributes["id"] != null)
                    {
                        pricingModelIDRef_ = pricingModelNode.Attributes["id"].Value;
                        PricingModel ob = new PricingModel(pricingModelNode);
                        IDManager.SetID(pricingModelIDRef_, ob);
                    }
                    else if (pricingModelNode.Attributes["href"] != null)
                    {
                        pricingModelIDRef_ = pricingModelNode.Attributes["href"].Value;
                    }
                    else
                    {
                        pricingModel_ = new PricingModel(pricingModelNode);
                    }
                }
                else
                {
                    pricingModel_ = new PricingModel(pricingModelNode);
                }
            }


            XmlNode timeNode = xmlNode.SelectSingleNode("time");

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


            XmlNode valuationDateNode = xmlNode.SelectSingleNode("valuationDate");

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


            XmlNode expiryTimeNode = xmlNode.SelectSingleNode("expiryTime");

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


            XmlNode cashflowTypeNode = xmlNode.SelectSingleNode("cashflowType");

            if (cashflowTypeNode != null)
            {
                if (cashflowTypeNode.Attributes["href"] != null || cashflowTypeNode.Attributes["id"] != null)
                {
                    if (cashflowTypeNode.Attributes["id"] != null)
                    {
                        cashflowTypeIDRef_ = cashflowTypeNode.Attributes["id"].Value;
                        CashflowType ob = new CashflowType(cashflowTypeNode);
                        IDManager.SetID(cashflowTypeIDRef_, ob);
                    }
                    else if (cashflowTypeNode.Attributes["href"] != null)
                    {
                        cashflowTypeIDRef_ = cashflowTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        cashflowType_ = new CashflowType(cashflowTypeNode);
                    }
                }
                else
                {
                    cashflowType_ = new CashflowType(cashflowTypeNode);
                }
            }


            XmlNodeList pointNodeList = xmlNode.SelectNodes("point");

            if (pointNodeList != null)
            {
                this.point_ = new List <PricingStructurePoint>();
                foreach (XmlNode item in pointNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            pointIDRef_ = item.Attributes["id"].Value;
                            point_.Add(new PricingStructurePoint(item));
                            IDManager.SetID(pointIDRef_, point_[point_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            pointIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            point_.Add(new PricingStructurePoint(item));
                        }
                    }
                    else
                    {
                        point_.Add(new PricingStructurePoint(item));
                    }
                }
            }
        }
示例#22
0
        public ServiceAdvisory(XmlNode xmlNode)
        {
            XmlNodeList categoryNodeList = xmlNode.SelectNodes("category");

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

            foreach (XmlNode item in categoryNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        categoryIDRef = item.Attributes["id"].Name;
                        ServiceAdvisoryCategory ob = ServiceAdvisoryCategory();
                        IDManager.SetID(categoryIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        categoryIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        category = new ServiceAdvisoryCategory(item);
                    }
                }
            }


            XmlNodeList descriptionNodeList = xmlNode.SelectNodes("description");

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

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


            XmlNodeList effectiveFromNodeList = xmlNode.SelectNodes("effectiveFrom");

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

            foreach (XmlNode item in effectiveFromNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        effectiveFromIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(effectiveFromIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        effectiveFromIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        effectiveFrom = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList effectiveToNodeList = xmlNode.SelectNodes("effectiveTo");

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

            foreach (XmlNode item in effectiveToNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        effectiveToIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(effectiveToIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        effectiveToIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        effectiveTo = new XsdTypeDateTime(item);
                    }
                }
            }
        }
 public ResponseMessageHeader(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode inReplyToNode = xmlNode.SelectSingleNode("inReplyTo");
     
     if (inReplyToNode != null)
     {
         if (inReplyToNode.Attributes["href"] != null || inReplyToNode.Attributes["id"] != null) 
         {
             if (inReplyToNode.Attributes["id"] != null) 
             {
                 inReplyToIDRef_ = inReplyToNode.Attributes["id"].Value;
                 MessageId ob = new MessageId(inReplyToNode);
                 IDManager.SetID(inReplyToIDRef_, ob);
             }
             else if (inReplyToNode.Attributes["href"] != null)
             {
                 inReplyToIDRef_ = inReplyToNode.Attributes["href"].Value;
             }
             else
             {
                 inReplyTo_ = new MessageId(inReplyToNode);
             }
         }
         else
         {
             inReplyTo_ = new MessageId(inReplyToNode);
         }
     }
     
 
     XmlNode sentByNode = xmlNode.SelectSingleNode("sentBy");
     
     if (sentByNode != null)
     {
         if (sentByNode.Attributes["href"] != null || sentByNode.Attributes["id"] != null) 
         {
             if (sentByNode.Attributes["id"] != null) 
             {
                 sentByIDRef_ = sentByNode.Attributes["id"].Value;
                 MessageAddress ob = new MessageAddress(sentByNode);
                 IDManager.SetID(sentByIDRef_, ob);
             }
             else if (sentByNode.Attributes["href"] != null)
             {
                 sentByIDRef_ = sentByNode.Attributes["href"].Value;
             }
             else
             {
                 sentBy_ = new MessageAddress(sentByNode);
             }
         }
         else
         {
             sentBy_ = new MessageAddress(sentByNode);
         }
     }
     
 
     XmlNodeList sendToNodeList = xmlNode.SelectNodes("sendTo");
     
     if (sendToNodeList != null)
     {
         this.sendTo_ = new List<MessageAddress>();
         foreach (XmlNode item in sendToNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     sendToIDRef_ = item.Attributes["id"].Value;
                     sendTo_.Add(new MessageAddress(item));
                     IDManager.SetID(sendToIDRef_, sendTo_[sendTo_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     sendToIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 sendTo_.Add(new MessageAddress(item));
                 }
             }
             else
             {
                 sendTo_.Add(new MessageAddress(item));
             }
         }
     }
     
 
     XmlNodeList copyToNodeList = xmlNode.SelectNodes("copyTo");
     
     if (copyToNodeList != null)
     {
         this.copyTo_ = new List<MessageAddress>();
         foreach (XmlNode item in copyToNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     copyToIDRef_ = item.Attributes["id"].Value;
                     copyTo_.Add(new MessageAddress(item));
                     IDManager.SetID(copyToIDRef_, copyTo_[copyTo_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     copyToIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 copyTo_.Add(new MessageAddress(item));
                 }
             }
             else
             {
                 copyTo_.Add(new MessageAddress(item));
             }
         }
     }
     
 
     XmlNode creationTimestampNode = xmlNode.SelectSingleNode("creationTimestamp");
     
     if (creationTimestampNode != null)
     {
         if (creationTimestampNode.Attributes["href"] != null || creationTimestampNode.Attributes["id"] != null) 
         {
             if (creationTimestampNode.Attributes["id"] != null) 
             {
                 creationTimestampIDRef_ = creationTimestampNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(creationTimestampNode);
                 IDManager.SetID(creationTimestampIDRef_, ob);
             }
             else if (creationTimestampNode.Attributes["href"] != null)
             {
                 creationTimestampIDRef_ = creationTimestampNode.Attributes["href"].Value;
             }
             else
             {
                 creationTimestamp_ = new XsdTypeDateTime(creationTimestampNode);
             }
         }
         else
         {
             creationTimestamp_ = new XsdTypeDateTime(creationTimestampNode);
         }
     }
     
 
     XmlNode expiryTimestampNode = xmlNode.SelectSingleNode("expiryTimestamp");
     
     if (expiryTimestampNode != null)
     {
         if (expiryTimestampNode.Attributes["href"] != null || expiryTimestampNode.Attributes["id"] != null) 
         {
             if (expiryTimestampNode.Attributes["id"] != null) 
             {
                 expiryTimestampIDRef_ = expiryTimestampNode.Attributes["id"].Value;
                 XsdTypeDateTime ob = new XsdTypeDateTime(expiryTimestampNode);
                 IDManager.SetID(expiryTimestampIDRef_, ob);
             }
             else if (expiryTimestampNode.Attributes["href"] != null)
             {
                 expiryTimestampIDRef_ = expiryTimestampNode.Attributes["href"].Value;
             }
             else
             {
                 expiryTimestamp_ = new XsdTypeDateTime(expiryTimestampNode);
             }
         }
         else
         {
             expiryTimestamp_ = new XsdTypeDateTime(expiryTimestampNode);
         }
     }
     
 
     XmlNode implementationSpecificationNode = xmlNode.SelectSingleNode("implementationSpecification");
     
     if (implementationSpecificationNode != null)
     {
         if (implementationSpecificationNode.Attributes["href"] != null || implementationSpecificationNode.Attributes["id"] != null) 
         {
             if (implementationSpecificationNode.Attributes["id"] != null) 
             {
                 implementationSpecificationIDRef_ = implementationSpecificationNode.Attributes["id"].Value;
                 ImplementationSpecification ob = new ImplementationSpecification(implementationSpecificationNode);
                 IDManager.SetID(implementationSpecificationIDRef_, ob);
             }
             else if (implementationSpecificationNode.Attributes["href"] != null)
             {
                 implementationSpecificationIDRef_ = implementationSpecificationNode.Attributes["href"].Value;
             }
             else
             {
                 implementationSpecification_ = new ImplementationSpecification(implementationSpecificationNode);
             }
         }
         else
         {
             implementationSpecification_ = new ImplementationSpecification(implementationSpecificationNode);
         }
     }
     
 
     XmlNodeList partyMessageInformationNodeList = xmlNode.SelectNodes("partyMessageInformation");
     
     if (partyMessageInformationNodeList != null)
     {
         this.partyMessageInformation_ = new List<PartyMessageInformation>();
         foreach (XmlNode item in partyMessageInformationNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     partyMessageInformationIDRef_ = item.Attributes["id"].Value;
                     partyMessageInformation_.Add(new PartyMessageInformation(item));
                     IDManager.SetID(partyMessageInformationIDRef_, partyMessageInformation_[partyMessageInformation_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     partyMessageInformationIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 partyMessageInformation_.Add(new PartyMessageInformation(item));
                 }
             }
             else
             {
                 partyMessageInformation_.Add(new PartyMessageInformation(item));
             }
         }
     }
     
 
     XmlNode SignatureNode = xmlNode.SelectSingleNode("Signature");
     
     if (SignatureNode != null)
     {
         if (SignatureNode.Attributes["href"] != null || SignatureNode.Attributes["id"] != null) 
         {
             if (SignatureNode.Attributes["id"] != null) 
             {
                 SignatureIDRef_ = SignatureNode.Attributes["id"].Value;
                 SignatureType ob = new SignatureType(SignatureNode);
                 IDManager.SetID(SignatureIDRef_, ob);
             }
             else if (SignatureNode.Attributes["href"] != null)
             {
                 SignatureIDRef_ = SignatureNode.Attributes["href"].Value;
             }
             else
             {
                 Signature_ = new SignatureType(SignatureNode);
             }
         }
         else
         {
             Signature_ = new SignatureType(SignatureNode);
         }
     }
     
 
 }
        public ClearingStatusItem(XmlNode xmlNode)
        {
            XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");

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


            XmlNode tradeReferenceInformationNode = xmlNode.SelectSingleNode("tradeReferenceInformation");

            if (tradeReferenceInformationNode != null)
            {
                if (tradeReferenceInformationNode.Attributes["href"] != null || tradeReferenceInformationNode.Attributes["id"] != null)
                {
                    if (tradeReferenceInformationNode.Attributes["id"] != null)
                    {
                        tradeReferenceInformationIDRef_ = tradeReferenceInformationNode.Attributes["id"].Value;
                        TradeReferenceInformation ob = new TradeReferenceInformation(tradeReferenceInformationNode);
                        IDManager.SetID(tradeReferenceInformationIDRef_, ob);
                    }
                    else if (tradeReferenceInformationNode.Attributes["href"] != null)
                    {
                        tradeReferenceInformationIDRef_ = tradeReferenceInformationNode.Attributes["href"].Value;
                    }
                    else
                    {
                        tradeReferenceInformation_ = new TradeReferenceInformation(tradeReferenceInformationNode);
                    }
                }
                else
                {
                    tradeReferenceInformation_ = new TradeReferenceInformation(tradeReferenceInformationNode);
                }
            }


            XmlNode tradeNode = xmlNode.SelectSingleNode("trade");

            if (tradeNode != null)
            {
                if (tradeNode.Attributes["href"] != null || tradeNode.Attributes["id"] != null)
                {
                    if (tradeNode.Attributes["id"] != null)
                    {
                        tradeIDRef_ = tradeNode.Attributes["id"].Value;
                        Trade ob = new Trade(tradeNode);
                        IDManager.SetID(tradeIDRef_, ob);
                    }
                    else if (tradeNode.Attributes["href"] != null)
                    {
                        tradeIDRef_ = tradeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        trade_ = new Trade(tradeNode);
                    }
                }
                else
                {
                    trade_ = new Trade(tradeNode);
                }
            }


            XmlNode clearingStatusValueNode = xmlNode.SelectSingleNode("clearingStatusValue");

            if (clearingStatusValueNode != null)
            {
                if (clearingStatusValueNode.Attributes["href"] != null || clearingStatusValueNode.Attributes["id"] != null)
                {
                    if (clearingStatusValueNode.Attributes["id"] != null)
                    {
                        clearingStatusValueIDRef_ = clearingStatusValueNode.Attributes["id"].Value;
                        ClearingStatusValue ob = new ClearingStatusValue(clearingStatusValueNode);
                        IDManager.SetID(clearingStatusValueIDRef_, ob);
                    }
                    else if (clearingStatusValueNode.Attributes["href"] != null)
                    {
                        clearingStatusValueIDRef_ = clearingStatusValueNode.Attributes["href"].Value;
                    }
                    else
                    {
                        clearingStatusValue_ = new ClearingStatusValue(clearingStatusValueNode);
                    }
                }
                else
                {
                    clearingStatusValue_ = new ClearingStatusValue(clearingStatusValueNode);
                }
            }


            XmlNode updatedDateTimeNode = xmlNode.SelectSingleNode("updatedDateTime");

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


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

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


            XmlNodeList statusAppliesToNodeList = xmlNode.SelectNodes("statusAppliesTo");

            if (statusAppliesToNodeList != null)
            {
                this.statusAppliesTo_ = new List <PartyReference>();
                foreach (XmlNode item in statusAppliesToNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            statusAppliesToIDRef_ = item.Attributes["id"].Value;
                            statusAppliesTo_.Add(new PartyReference(item));
                            IDManager.SetID(statusAppliesToIDRef_, statusAppliesTo_[statusAppliesTo_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            statusAppliesToIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            statusAppliesTo_.Add(new PartyReference(item));
                        }
                    }
                    else
                    {
                        statusAppliesTo_.Add(new PartyReference(item));
                    }
                }
            }
        }
示例#25
0
        public PricingStructureValuation(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList baseDateNodeList = xmlNode.SelectNodes("baseDate");

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

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


            XmlNodeList spotDateNodeList = xmlNode.SelectNodes("spotDate");

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

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


            XmlNodeList inputDataDateNodeList = xmlNode.SelectNodes("inputDataDate");

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

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


            XmlNodeList endDateNodeList = xmlNode.SelectNodes("endDate");

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

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


            XmlNodeList buildDateTimeNodeList = xmlNode.SelectNodes("buildDateTime");

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

            foreach (XmlNode item in buildDateTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        buildDateTimeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(buildDateTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        buildDateTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        buildDateTime = new XsdTypeDateTime(item);
                    }
                }
            }
        }
        public WeightedAveragingObservation(XmlNode xmlNode)
        {
            XmlNodeList dateTimeNodeList = xmlNode.SelectNodes("dateTime");

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

            foreach (XmlNode item in dateTimeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        dateTimeIDRef = item.Attributes["id"].Name;
                        XsdTypeDateTime ob = XsdTypeDateTime();
                        IDManager.SetID(dateTimeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        dateTimeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        dateTime = new XsdTypeDateTime(item);
                    }
                }
            }


            XmlNodeList observationNumberNodeList = xmlNode.SelectNodes("observationNumber");

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

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


            XmlNodeList weightNodeList = xmlNode.SelectNodes("weight");

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

            foreach (XmlNode item in weightNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        weightIDRef = item.Attributes["id"].Name;
                        NonNegativeDecimal ob = NonNegativeDecimal();
                        IDManager.SetID(weightIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        weightIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        weight = new NonNegativeDecimal(item);
                    }
                }
            }
        }