public BestFitTrade(XmlNode xmlNode)
 {
     XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");
     if (tradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(tradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeIdentifier = new TradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList differencesNodeList = xmlNode.SelectNodes("differences");
     
     foreach (XmlNode item in differencesNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 differencesIDRef = item.Attributes["id"].Name;
                 List<TradeDifference> ob = new List<TradeDifference>();
                 ob.Add(new TradeDifference(item));
                 IDManager.SetID(differencesIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 differencesIDRef = item.Attributes["href"].Name;
             }
             else
             {
             differences.Add(new TradeDifference(item));
             }
         }
     }
     
 
 }
        public BestFitTrade(XmlNode xmlNode)
        {
            XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");

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

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


            XmlNodeList differencesNodeList = xmlNode.SelectNodes("differences");

            foreach (XmlNode item in differencesNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        differencesIDRef = item.Attributes["id"].Name;
                        List <TradeDifference> ob = new List <TradeDifference>();
                        ob.Add(new TradeDifference(item));
                        IDManager.SetID(differencesIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        differencesIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        differences.Add(new TradeDifference(item));
                    }
                }
            }
        }
 public PartyTradeIdentifier(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList linkIdNodeList = xmlNode.SelectNodes("linkId");
     
     if (linkIdNodeList != null)
     {
         this.linkId_ = new List<LinkId>();
         foreach (XmlNode item in linkIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     linkIdIDRef_ = item.Attributes["id"].Value;
                     linkId_.Add(new LinkId(item));
                     IDManager.SetID(linkIdIDRef_, linkId_[linkId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     linkIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 linkId_.Add(new LinkId(item));
                 }
             }
             else
             {
                 linkId_.Add(new LinkId(item));
             }
         }
     }
     
 
     XmlNodeList allocationTradeIdNodeList = xmlNode.SelectNodes("allocationTradeId");
     
     if (allocationTradeIdNodeList != null)
     {
         this.allocationTradeId_ = new List<TradeIdentifier>();
         foreach (XmlNode item in allocationTradeIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     allocationTradeIdIDRef_ = item.Attributes["id"].Value;
                     allocationTradeId_.Add(new TradeIdentifier(item));
                     IDManager.SetID(allocationTradeIdIDRef_, allocationTradeId_[allocationTradeId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     allocationTradeIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 allocationTradeId_.Add(new TradeIdentifier(item));
                 }
             }
             else
             {
                 allocationTradeId_.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNode blockTradeIdNode = xmlNode.SelectSingleNode("blockTradeId");
     
     if (blockTradeIdNode != null)
     {
         if (blockTradeIdNode.Attributes["href"] != null || blockTradeIdNode.Attributes["id"] != null) 
         {
             if (blockTradeIdNode.Attributes["id"] != null) 
             {
                 blockTradeIdIDRef_ = blockTradeIdNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(blockTradeIdNode);
                 IDManager.SetID(blockTradeIdIDRef_, ob);
             }
             else if (blockTradeIdNode.Attributes["href"] != null)
             {
                 blockTradeIdIDRef_ = blockTradeIdNode.Attributes["href"].Value;
             }
             else
             {
                 blockTradeId_ = new TradeIdentifier(blockTradeIdNode);
             }
         }
         else
         {
             blockTradeId_ = new TradeIdentifier(blockTradeIdNode);
         }
     }
     
 
     XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");
     
     if (originatingTradeIdNodeList != null)
     {
         this.originatingTradeId_ = new List<TradeIdentifier>();
         foreach (XmlNode item in originatingTradeIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     originatingTradeIdIDRef_ = item.Attributes["id"].Value;
                     originatingTradeId_.Add(new TradeIdentifier(item));
                     IDManager.SetID(originatingTradeIdIDRef_, originatingTradeId_[originatingTradeId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     originatingTradeIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 originatingTradeId_.Add(new TradeIdentifier(item));
                 }
             }
             else
             {
                 originatingTradeId_.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList productComponentIdentifierNodeList = xmlNode.SelectNodes("productComponentIdentifier");
     
     if (productComponentIdentifierNodeList != null)
     {
         this.productComponentIdentifier_ = new List<ProductComponentIdentifier>();
         foreach (XmlNode item in productComponentIdentifierNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     productComponentIdentifierIDRef_ = item.Attributes["id"].Value;
                     productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
                     IDManager.SetID(productComponentIdentifierIDRef_, productComponentIdentifier_[productComponentIdentifier_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     productComponentIdentifierIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
                 }
             }
             else
             {
                 productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
             }
         }
     }
     
 
 }
        public AllocationApproved(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList blockTradeIdentifierNodeList = xmlNode.SelectNodes("blockTradeIdentifier");

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

            foreach (XmlNode item in blockTradeIdentifierNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        blockTradeIdentifierIDRef = item.Attributes["id"].Name;
                        TradeIdentifier ob = TradeIdentifier();
                        IDManager.SetID(blockTradeIdentifierIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        blockTradeIdentifierIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        blockTradeIdentifier = new TradeIdentifier(item);
                    }
                }
            }


            XmlNodeList allocationsNodeList = xmlNode.SelectNodes("allocations");

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

            foreach (XmlNode item in allocationsNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        allocationsIDRef = item.Attributes["id"].Name;
                        Allocations ob = Allocations();
                        IDManager.SetID(allocationsIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        allocationsIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        allocations = new Allocations(item);
                    }
                }
            }


            XmlNodeList partyNodeList = xmlNode.SelectNodes("party");

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


            XmlNodeList accountNodeList = xmlNode.SelectNodes("account");

            foreach (XmlNode item in accountNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        accountIDRef = item.Attributes["id"].Name;
                        List <Account> ob = new List <Account>();
                        ob.Add(new Account(item));
                        IDManager.SetID(accountIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        accountIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        account.Add(new Account(item));
                    }
                }
            }
        }
 public BestFitTrade(XmlNode xmlNode)
 {
     XmlNode tradeIdentifierNode = xmlNode.SelectSingleNode("tradeIdentifier");
     
     if (tradeIdentifierNode != null)
     {
         if (tradeIdentifierNode.Attributes["href"] != null || tradeIdentifierNode.Attributes["id"] != null) 
         {
             if (tradeIdentifierNode.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(tradeIdentifierNode);
                 IDManager.SetID(tradeIdentifierIDRef_, ob);
             }
             else if (tradeIdentifierNode.Attributes["href"] != null)
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["href"].Value;
             }
             else
             {
                 tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
             }
         }
         else
         {
             tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
         }
     }
     
 
     XmlNodeList differencesNodeList = xmlNode.SelectNodes("differences");
     
     if (differencesNodeList != null)
     {
         this.differences_ = new List<TradeDifference>();
         foreach (XmlNode item in differencesNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     differencesIDRef_ = item.Attributes["id"].Value;
                     differences_.Add(new TradeDifference(item));
                     IDManager.SetID(differencesIDRef_, differences_[differences_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     differencesIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 differences_.Add(new TradeDifference(item));
                 }
             }
             else
             {
                 differences_.Add(new TradeDifference(item));
             }
         }
     }
     
 
 }
 public EventIdentifier(XmlNode xmlNode)
 {
     XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");
     if (correlationIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in correlationIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 correlationIdIDRef = item.Attributes["id"].Name;
                 CorrelationId ob = CorrelationId();
                 IDManager.SetID(correlationIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 correlationIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 correlationId = new CorrelationId(item);
             }
         }
     }
     
 
     XmlNodeList sequenceNumberNodeList = xmlNode.SelectNodes("sequenceNumber");
     if (sequenceNumberNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in sequenceNumberNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef = item.Attributes["id"].Name;
                 XsdTypePositiveInteger ob = XsdTypePositiveInteger();
                 IDManager.SetID(sequenceNumberIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 sequenceNumberIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 sequenceNumber = new XsdTypePositiveInteger(item);
             }
         }
     }
     
 
     XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");
     if (tradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in tradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(tradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 tradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 tradeIdentifier = new TradeIdentifier(item);
             }
         }
     }
     
 
 }
 public PartyTradeIdentifier(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList linkIdNodeList = xmlNode.SelectNodes("linkId");
     
     foreach (XmlNode item in linkIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 linkIdIDRef = item.Attributes["id"].Name;
                 List<LinkId> ob = new List<LinkId>();
                 ob.Add(new LinkId(item));
                 IDManager.SetID(linkIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 linkIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             linkId.Add(new LinkId(item));
             }
         }
     }
     
 
     XmlNodeList allocationTradeIdNodeList = xmlNode.SelectNodes("allocationTradeId");
     
     foreach (XmlNode item in allocationTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocationTradeIdIDRef = item.Attributes["id"].Name;
                 List<TradeIdentifier> ob = new List<TradeIdentifier>();
                 ob.Add(new TradeIdentifier(item));
                 IDManager.SetID(allocationTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocationTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             allocationTradeId.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList blockTradeIdNodeList = xmlNode.SelectNodes("blockTradeId");
     if (blockTradeIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in blockTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 blockTradeIdIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(blockTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 blockTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 blockTradeId = new TradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");
     
     foreach (XmlNode item in originatingTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originatingTradeIdIDRef = item.Attributes["id"].Name;
                 List<TradeIdentifier> ob = new List<TradeIdentifier>();
                 ob.Add(new TradeIdentifier(item));
                 IDManager.SetID(originatingTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originatingTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             originatingTradeId.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList productComponentIdentifierNodeList = xmlNode.SelectNodes("productComponentIdentifier");
     
     foreach (XmlNode item in productComponentIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 productComponentIdentifierIDRef = item.Attributes["id"].Name;
                 List<ProductComponentIdentifier> ob = new List<ProductComponentIdentifier>();
                 ob.Add(new ProductComponentIdentifier(item));
                 IDManager.SetID(productComponentIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 productComponentIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             productComponentIdentifier.Add(new ProductComponentIdentifier(item));
             }
         }
     }
     
 
 }
Exemple #8
0
        public CompressionActivity(XmlNode xmlNode)
        {
            XmlNode compressionTypeNode = xmlNode.SelectSingleNode("compressionType");

            if (compressionTypeNode != null)
            {
                if (compressionTypeNode.Attributes["href"] != null || compressionTypeNode.Attributes["id"] != null)
                {
                    if (compressionTypeNode.Attributes["id"] != null)
                    {
                        compressionTypeIDRef_ = compressionTypeNode.Attributes["id"].Value;
                        CompressionType ob = new CompressionType(compressionTypeNode);
                        IDManager.SetID(compressionTypeIDRef_, ob);
                    }
                    else if (compressionTypeNode.Attributes["href"] != null)
                    {
                        compressionTypeIDRef_ = compressionTypeNode.Attributes["href"].Value;
                    }
                    else
                    {
                        compressionType_ = new CompressionType(compressionTypeNode);
                    }
                }
                else
                {
                    compressionType_ = new CompressionType(compressionTypeNode);
                }
            }


            XmlNode replacementTradeIdentifierNode = xmlNode.SelectSingleNode("replacementTradeIdentifier");

            if (replacementTradeIdentifierNode != null)
            {
                if (replacementTradeIdentifierNode.Attributes["href"] != null || replacementTradeIdentifierNode.Attributes["id"] != null)
                {
                    if (replacementTradeIdentifierNode.Attributes["id"] != null)
                    {
                        replacementTradeIdentifierIDRef_ = replacementTradeIdentifierNode.Attributes["id"].Value;
                        TradeIdentifier ob = new TradeIdentifier(replacementTradeIdentifierNode);
                        IDManager.SetID(replacementTradeIdentifierIDRef_, ob);
                    }
                    else if (replacementTradeIdentifierNode.Attributes["href"] != null)
                    {
                        replacementTradeIdentifierIDRef_ = replacementTradeIdentifierNode.Attributes["href"].Value;
                    }
                    else
                    {
                        replacementTradeIdentifier_ = new TradeIdentifier(replacementTradeIdentifierNode);
                    }
                }
                else
                {
                    replacementTradeIdentifier_ = new TradeIdentifier(replacementTradeIdentifierNode);
                }
            }


            XmlNodeList originatingTradeIdentifierNodeList = xmlNode.SelectNodes("originatingTradeIdentifier");

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


            XmlNode replacementTradeIdNode = xmlNode.SelectSingleNode("replacementTradeId");

            if (replacementTradeIdNode != null)
            {
                if (replacementTradeIdNode.Attributes["href"] != null || replacementTradeIdNode.Attributes["id"] != null)
                {
                    if (replacementTradeIdNode.Attributes["id"] != null)
                    {
                        replacementTradeIdIDRef_ = replacementTradeIdNode.Attributes["id"].Value;
                        TradeId ob = new TradeId(replacementTradeIdNode);
                        IDManager.SetID(replacementTradeIdIDRef_, ob);
                    }
                    else if (replacementTradeIdNode.Attributes["href"] != null)
                    {
                        replacementTradeIdIDRef_ = replacementTradeIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        replacementTradeId_ = new TradeId(replacementTradeIdNode);
                    }
                }
                else
                {
                    replacementTradeId_ = new TradeId(replacementTradeIdNode);
                }
            }


            XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");

            if (originatingTradeIdNodeList != null)
            {
                this.originatingTradeId_ = new List <TradeId>();
                foreach (XmlNode item in originatingTradeIdNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            originatingTradeIdIDRef_ = item.Attributes["id"].Value;
                            originatingTradeId_.Add(new TradeId(item));
                            IDManager.SetID(originatingTradeIdIDRef_, originatingTradeId_[originatingTradeId_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            originatingTradeIdIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            originatingTradeId_.Add(new TradeId(item));
                        }
                    }
                    else
                    {
                        originatingTradeId_.Add(new TradeId(item));
                    }
                }
            }
        }
 public EventIdentifier(XmlNode xmlNode)
 {
     XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");
     
     if (correlationIdNode != null)
     {
         if (correlationIdNode.Attributes["href"] != null || correlationIdNode.Attributes["id"] != null) 
         {
             if (correlationIdNode.Attributes["id"] != null) 
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["id"].Value;
                 CorrelationId ob = new CorrelationId(correlationIdNode);
                 IDManager.SetID(correlationIdIDRef_, ob);
             }
             else if (correlationIdNode.Attributes["href"] != null)
             {
                 correlationIdIDRef_ = correlationIdNode.Attributes["href"].Value;
             }
             else
             {
                 correlationId_ = new CorrelationId(correlationIdNode);
             }
         }
         else
         {
             correlationId_ = new CorrelationId(correlationIdNode);
         }
     }
     
 
     XmlNode sequenceNumberNode = xmlNode.SelectSingleNode("sequenceNumber");
     
     if (sequenceNumberNode != null)
     {
         if (sequenceNumberNode.Attributes["href"] != null || sequenceNumberNode.Attributes["id"] != null) 
         {
             if (sequenceNumberNode.Attributes["id"] != null) 
             {
                 sequenceNumberIDRef_ = sequenceNumberNode.Attributes["id"].Value;
                 XsdTypePositiveInteger ob = new XsdTypePositiveInteger(sequenceNumberNode);
                 IDManager.SetID(sequenceNumberIDRef_, ob);
             }
             else if (sequenceNumberNode.Attributes["href"] != null)
             {
                 sequenceNumberIDRef_ = sequenceNumberNode.Attributes["href"].Value;
             }
             else
             {
                 sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
             }
         }
         else
         {
             sequenceNumber_ = new XsdTypePositiveInteger(sequenceNumberNode);
         }
     }
     
 
     XmlNode tradeIdentifierNode = xmlNode.SelectSingleNode("tradeIdentifier");
     
     if (tradeIdentifierNode != null)
     {
         if (tradeIdentifierNode.Attributes["href"] != null || tradeIdentifierNode.Attributes["id"] != null) 
         {
             if (tradeIdentifierNode.Attributes["id"] != null) 
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(tradeIdentifierNode);
                 IDManager.SetID(tradeIdentifierIDRef_, ob);
             }
             else if (tradeIdentifierNode.Attributes["href"] != null)
             {
                 tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["href"].Value;
             }
             else
             {
                 tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
             }
         }
         else
         {
             tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
         }
     }
     
 
 }
Exemple #10
0
        public PartyTradeIdentifier(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList linkIdNodeList = xmlNode.SelectNodes("linkId");

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


            XmlNodeList allocationTradeIdNodeList = xmlNode.SelectNodes("allocationTradeId");

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


            XmlNodeList blockTradeIdNodeList = xmlNode.SelectNodes("blockTradeId");

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

            foreach (XmlNode item in blockTradeIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        blockTradeIdIDRef = item.Attributes["id"].Name;
                        TradeIdentifier ob = TradeIdentifier();
                        IDManager.SetID(blockTradeIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        blockTradeIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        blockTradeId = new TradeIdentifier(item);
                    }
                }
            }


            XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");

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


            XmlNodeList productComponentIdentifierNodeList = xmlNode.SelectNodes("productComponentIdentifier");

            foreach (XmlNode item in productComponentIdentifierNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        productComponentIdentifierIDRef = item.Attributes["id"].Name;
                        List <ProductComponentIdentifier> ob = new List <ProductComponentIdentifier>();
                        ob.Add(new ProductComponentIdentifier(item));
                        IDManager.SetID(productComponentIdentifierIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        productComponentIdentifierIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        productComponentIdentifier.Add(new ProductComponentIdentifier(item));
                    }
                }
            }
        }
 public CompressionActivity(XmlNode xmlNode)
 {
     XmlNodeList compressionTypeNodeList = xmlNode.SelectNodes("compressionType");
     if (compressionTypeNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in compressionTypeNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 compressionTypeIDRef = item.Attributes["id"].Name;
                 CompressionType ob = CompressionType();
                 IDManager.SetID(compressionTypeIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 compressionTypeIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 compressionType = new CompressionType(item);
             }
         }
     }
     
 
     XmlNodeList replacementTradeIdentifierNodeList = xmlNode.SelectNodes("replacementTradeIdentifier");
     if (replacementTradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in replacementTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 replacementTradeIdentifierIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(replacementTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 replacementTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 replacementTradeIdentifier = new TradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList originatingTradeIdentifierNodeList = xmlNode.SelectNodes("originatingTradeIdentifier");
     
     foreach (XmlNode item in originatingTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originatingTradeIdentifierIDRef = item.Attributes["id"].Name;
                 List<TradeIdentifier> ob = new List<TradeIdentifier>();
                 ob.Add(new TradeIdentifier(item));
                 IDManager.SetID(originatingTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originatingTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
             originatingTradeIdentifier.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNodeList replacementTradeIdNodeList = xmlNode.SelectNodes("replacementTradeId");
     if (replacementTradeIdNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in replacementTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 replacementTradeIdIDRef = item.Attributes["id"].Name;
                 TradeId ob = TradeId();
                 IDManager.SetID(replacementTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 replacementTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 replacementTradeId = new TradeId(item);
             }
         }
     }
     
 
     XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");
     
     foreach (XmlNode item in originatingTradeIdNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 originatingTradeIdIDRef = item.Attributes["id"].Name;
                 List<TradeId> ob = new List<TradeId>();
                 ob.Add(new TradeId(item));
                 IDManager.SetID(originatingTradeIdIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 originatingTradeIdIDRef = item.Attributes["href"].Name;
             }
             else
             {
             originatingTradeId.Add(new TradeId(item));
             }
         }
     }
     
 
 }
 public CompressionActivity(XmlNode xmlNode)
 {
     XmlNode compressionTypeNode = xmlNode.SelectSingleNode("compressionType");
     
     if (compressionTypeNode != null)
     {
         if (compressionTypeNode.Attributes["href"] != null || compressionTypeNode.Attributes["id"] != null) 
         {
             if (compressionTypeNode.Attributes["id"] != null) 
             {
                 compressionTypeIDRef_ = compressionTypeNode.Attributes["id"].Value;
                 CompressionType ob = new CompressionType(compressionTypeNode);
                 IDManager.SetID(compressionTypeIDRef_, ob);
             }
             else if (compressionTypeNode.Attributes["href"] != null)
             {
                 compressionTypeIDRef_ = compressionTypeNode.Attributes["href"].Value;
             }
             else
             {
                 compressionType_ = new CompressionType(compressionTypeNode);
             }
         }
         else
         {
             compressionType_ = new CompressionType(compressionTypeNode);
         }
     }
     
 
     XmlNode replacementTradeIdentifierNode = xmlNode.SelectSingleNode("replacementTradeIdentifier");
     
     if (replacementTradeIdentifierNode != null)
     {
         if (replacementTradeIdentifierNode.Attributes["href"] != null || replacementTradeIdentifierNode.Attributes["id"] != null) 
         {
             if (replacementTradeIdentifierNode.Attributes["id"] != null) 
             {
                 replacementTradeIdentifierIDRef_ = replacementTradeIdentifierNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(replacementTradeIdentifierNode);
                 IDManager.SetID(replacementTradeIdentifierIDRef_, ob);
             }
             else if (replacementTradeIdentifierNode.Attributes["href"] != null)
             {
                 replacementTradeIdentifierIDRef_ = replacementTradeIdentifierNode.Attributes["href"].Value;
             }
             else
             {
                 replacementTradeIdentifier_ = new TradeIdentifier(replacementTradeIdentifierNode);
             }
         }
         else
         {
             replacementTradeIdentifier_ = new TradeIdentifier(replacementTradeIdentifierNode);
         }
     }
     
 
     XmlNodeList originatingTradeIdentifierNodeList = xmlNode.SelectNodes("originatingTradeIdentifier");
     
     if (originatingTradeIdentifierNodeList != null)
     {
         this.originatingTradeIdentifier_ = new List<TradeIdentifier>();
         foreach (XmlNode item in originatingTradeIdentifierNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     originatingTradeIdentifierIDRef_ = item.Attributes["id"].Value;
                     originatingTradeIdentifier_.Add(new TradeIdentifier(item));
                     IDManager.SetID(originatingTradeIdentifierIDRef_, originatingTradeIdentifier_[originatingTradeIdentifier_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     originatingTradeIdentifierIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 originatingTradeIdentifier_.Add(new TradeIdentifier(item));
                 }
             }
             else
             {
                 originatingTradeIdentifier_.Add(new TradeIdentifier(item));
             }
         }
     }
     
 
     XmlNode replacementTradeIdNode = xmlNode.SelectSingleNode("replacementTradeId");
     
     if (replacementTradeIdNode != null)
     {
         if (replacementTradeIdNode.Attributes["href"] != null || replacementTradeIdNode.Attributes["id"] != null) 
         {
             if (replacementTradeIdNode.Attributes["id"] != null) 
             {
                 replacementTradeIdIDRef_ = replacementTradeIdNode.Attributes["id"].Value;
                 TradeId ob = new TradeId(replacementTradeIdNode);
                 IDManager.SetID(replacementTradeIdIDRef_, ob);
             }
             else if (replacementTradeIdNode.Attributes["href"] != null)
             {
                 replacementTradeIdIDRef_ = replacementTradeIdNode.Attributes["href"].Value;
             }
             else
             {
                 replacementTradeId_ = new TradeId(replacementTradeIdNode);
             }
         }
         else
         {
             replacementTradeId_ = new TradeId(replacementTradeIdNode);
         }
     }
     
 
     XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");
     
     if (originatingTradeIdNodeList != null)
     {
         this.originatingTradeId_ = new List<TradeId>();
         foreach (XmlNode item in originatingTradeIdNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     originatingTradeIdIDRef_ = item.Attributes["id"].Value;
                     originatingTradeId_.Add(new TradeId(item));
                     IDManager.SetID(originatingTradeIdIDRef_, originatingTradeId_[originatingTradeId_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     originatingTradeIdIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 originatingTradeId_.Add(new TradeId(item));
                 }
             }
             else
             {
                 originatingTradeId_.Add(new TradeId(item));
             }
         }
     }
     
 
 }
Exemple #13
0
        public PartyTradeIdentifier(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNodeList linkIdNodeList = xmlNode.SelectNodes("linkId");

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


            XmlNodeList allocationTradeIdNodeList = xmlNode.SelectNodes("allocationTradeId");

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


            XmlNode blockTradeIdNode = xmlNode.SelectSingleNode("blockTradeId");

            if (blockTradeIdNode != null)
            {
                if (blockTradeIdNode.Attributes["href"] != null || blockTradeIdNode.Attributes["id"] != null)
                {
                    if (blockTradeIdNode.Attributes["id"] != null)
                    {
                        blockTradeIdIDRef_ = blockTradeIdNode.Attributes["id"].Value;
                        TradeIdentifier ob = new TradeIdentifier(blockTradeIdNode);
                        IDManager.SetID(blockTradeIdIDRef_, ob);
                    }
                    else if (blockTradeIdNode.Attributes["href"] != null)
                    {
                        blockTradeIdIDRef_ = blockTradeIdNode.Attributes["href"].Value;
                    }
                    else
                    {
                        blockTradeId_ = new TradeIdentifier(blockTradeIdNode);
                    }
                }
                else
                {
                    blockTradeId_ = new TradeIdentifier(blockTradeIdNode);
                }
            }


            XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");

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


            XmlNodeList productComponentIdentifierNodeList = xmlNode.SelectNodes("productComponentIdentifier");

            if (productComponentIdentifierNodeList != null)
            {
                this.productComponentIdentifier_ = new List <ProductComponentIdentifier>();
                foreach (XmlNode item in productComponentIdentifierNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            productComponentIdentifierIDRef_ = item.Attributes["id"].Value;
                            productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
                            IDManager.SetID(productComponentIdentifierIDRef_, productComponentIdentifier_[productComponentIdentifier_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            productComponentIdentifierIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
                        }
                    }
                    else
                    {
                        productComponentIdentifier_.Add(new ProductComponentIdentifier(item));
                    }
                }
            }
        }
Exemple #14
0
        public BestFitTrade(XmlNode xmlNode)
        {
            XmlNode tradeIdentifierNode = xmlNode.SelectSingleNode("tradeIdentifier");

            if (tradeIdentifierNode != null)
            {
                if (tradeIdentifierNode.Attributes["href"] != null || tradeIdentifierNode.Attributes["id"] != null)
                {
                    if (tradeIdentifierNode.Attributes["id"] != null)
                    {
                        tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["id"].Value;
                        TradeIdentifier ob = new TradeIdentifier(tradeIdentifierNode);
                        IDManager.SetID(tradeIdentifierIDRef_, ob);
                    }
                    else if (tradeIdentifierNode.Attributes["href"] != null)
                    {
                        tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["href"].Value;
                    }
                    else
                    {
                        tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
                    }
                }
                else
                {
                    tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
                }
            }


            XmlNodeList differencesNodeList = xmlNode.SelectNodes("differences");

            if (differencesNodeList != null)
            {
                this.differences_ = new List <TradeDifference>();
                foreach (XmlNode item in differencesNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            differencesIDRef_ = item.Attributes["id"].Value;
                            differences_.Add(new TradeDifference(item));
                            IDManager.SetID(differencesIDRef_, differences_[differences_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            differencesIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            differences_.Add(new TradeDifference(item));
                        }
                    }
                    else
                    {
                        differences_.Add(new TradeDifference(item));
                    }
                }
            }
        }
        public EventIdentifier(XmlNode xmlNode)
        {
            XmlNodeList correlationIdNodeList = xmlNode.SelectNodes("correlationId");

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

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


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

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

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


            XmlNodeList tradeIdentifierNodeList = xmlNode.SelectNodes("tradeIdentifier");

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

            foreach (XmlNode item in tradeIdentifierNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        tradeIdentifierIDRef = item.Attributes["id"].Name;
                        TradeIdentifier ob = TradeIdentifier();
                        IDManager.SetID(tradeIdentifierIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        tradeIdentifierIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        tradeIdentifier = new TradeIdentifier(item);
                    }
                }
            }
        }
 public AllocationRefused(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNodeList blockTradeIdentifierNodeList = xmlNode.SelectNodes("blockTradeIdentifier");
     if (blockTradeIdentifierNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in blockTradeIdentifierNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 blockTradeIdentifierIDRef = item.Attributes["id"].Name;
                 TradeIdentifier ob = TradeIdentifier();
                 IDManager.SetID(blockTradeIdentifierIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 blockTradeIdentifierIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 blockTradeIdentifier = new TradeIdentifier(item);
             }
         }
     }
     
 
     XmlNodeList allocationsNodeList = xmlNode.SelectNodes("allocations");
     if (allocationsNodeList.Count > 1 )
     {
             throw new Exception();
     }
     
     foreach (XmlNode item in allocationsNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 allocationsIDRef = item.Attributes["id"].Name;
                 Allocations ob = Allocations();
                 IDManager.SetID(allocationsIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 allocationsIDRef = item.Attributes["href"].Name;
             }
             else
             {
                 allocations = new Allocations(item);
             }
         }
     }
     
 
     XmlNodeList partyNodeList = xmlNode.SelectNodes("party");
     
     foreach (XmlNode item in partyNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 partyIDRef = item.Attributes["id"].Name;
                 List<Party> ob = new List<Party>();
                 ob.Add(new Party(item));
                 IDManager.SetID(partyIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 partyIDRef = item.Attributes["href"].Name;
             }
             else
             {
             party.Add(new Party(item));
             }
         }
     }
     
 
     XmlNodeList accountNodeList = xmlNode.SelectNodes("account");
     
     foreach (XmlNode item in accountNodeList)
     {
         if (item.Attributes["href"] != null || item.Attributes["id"] == null) 
         {
             if (item.Attributes["id"] != null) 
             {
                 accountIDRef = item.Attributes["id"].Name;
                 List<Account> ob = new List<Account>();
                 ob.Add(new Account(item));
                 IDManager.SetID(accountIDRef, ob);
             }
             else if (item.Attributes.ToString() == "href")
             {
                 accountIDRef = item.Attributes["href"].Name;
             }
             else
             {
             account.Add(new Account(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));
             }
         }
     }
     
 
 }
        public RequestAllocationRetracted(XmlNode xmlNode)
            : base(xmlNode)
        {
            XmlNode blockTradeIdentifierNode = xmlNode.SelectSingleNode("blockTradeIdentifier");

            if (blockTradeIdentifierNode != null)
            {
                if (blockTradeIdentifierNode.Attributes["href"] != null || blockTradeIdentifierNode.Attributes["id"] != null)
                {
                    if (blockTradeIdentifierNode.Attributes["id"] != null)
                    {
                        blockTradeIdentifierIDRef_ = blockTradeIdentifierNode.Attributes["id"].Value;
                        TradeIdentifier ob = new TradeIdentifier(blockTradeIdentifierNode);
                        IDManager.SetID(blockTradeIdentifierIDRef_, ob);
                    }
                    else if (blockTradeIdentifierNode.Attributes["href"] != null)
                    {
                        blockTradeIdentifierIDRef_ = blockTradeIdentifierNode.Attributes["href"].Value;
                    }
                    else
                    {
                        blockTradeIdentifier_ = new TradeIdentifier(blockTradeIdentifierNode);
                    }
                }
                else
                {
                    blockTradeIdentifier_ = new TradeIdentifier(blockTradeIdentifierNode);
                }
            }


            XmlNode allocationsNode = xmlNode.SelectSingleNode("allocations");

            if (allocationsNode != null)
            {
                if (allocationsNode.Attributes["href"] != null || allocationsNode.Attributes["id"] != null)
                {
                    if (allocationsNode.Attributes["id"] != null)
                    {
                        allocationsIDRef_ = allocationsNode.Attributes["id"].Value;
                        Allocations ob = new Allocations(allocationsNode);
                        IDManager.SetID(allocationsIDRef_, ob);
                    }
                    else if (allocationsNode.Attributes["href"] != null)
                    {
                        allocationsIDRef_ = allocationsNode.Attributes["href"].Value;
                    }
                    else
                    {
                        allocations_ = new Allocations(allocationsNode);
                    }
                }
                else
                {
                    allocations_ = new Allocations(allocationsNode);
                }
            }


            XmlNodeList partyNodeList = xmlNode.SelectNodes("party");

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


            XmlNodeList accountNodeList = xmlNode.SelectNodes("account");

            if (accountNodeList != null)
            {
                this.account_ = new List <Account>();
                foreach (XmlNode item in accountNodeList)
                {
                    if (item.Attributes["href"] != null || item.Attributes["id"] != null)
                    {
                        if (item.Attributes["id"] != null)
                        {
                            accountIDRef_ = item.Attributes["id"].Value;
                            account_.Add(new Account(item));
                            IDManager.SetID(accountIDRef_, account_[account_.Count - 1]);
                        }
                        else if (item.Attributes["href"] != null)
                        {
                            accountIDRef_ = item.Attributes["href"].Value;
                        }
                        else
                        {
                            account_.Add(new Account(item));
                        }
                    }
                    else
                    {
                        account_.Add(new Account(item));
                    }
                }
            }
        }
 public AllocationRefused(XmlNode xmlNode)
 : base(xmlNode)
 {
     XmlNode blockTradeIdentifierNode = xmlNode.SelectSingleNode("blockTradeIdentifier");
     
     if (blockTradeIdentifierNode != null)
     {
         if (blockTradeIdentifierNode.Attributes["href"] != null || blockTradeIdentifierNode.Attributes["id"] != null) 
         {
             if (blockTradeIdentifierNode.Attributes["id"] != null) 
             {
                 blockTradeIdentifierIDRef_ = blockTradeIdentifierNode.Attributes["id"].Value;
                 TradeIdentifier ob = new TradeIdentifier(blockTradeIdentifierNode);
                 IDManager.SetID(blockTradeIdentifierIDRef_, ob);
             }
             else if (blockTradeIdentifierNode.Attributes["href"] != null)
             {
                 blockTradeIdentifierIDRef_ = blockTradeIdentifierNode.Attributes["href"].Value;
             }
             else
             {
                 blockTradeIdentifier_ = new TradeIdentifier(blockTradeIdentifierNode);
             }
         }
         else
         {
             blockTradeIdentifier_ = new TradeIdentifier(blockTradeIdentifierNode);
         }
     }
     
 
     XmlNode allocationsNode = xmlNode.SelectSingleNode("allocations");
     
     if (allocationsNode != null)
     {
         if (allocationsNode.Attributes["href"] != null || allocationsNode.Attributes["id"] != null) 
         {
             if (allocationsNode.Attributes["id"] != null) 
             {
                 allocationsIDRef_ = allocationsNode.Attributes["id"].Value;
                 Allocations ob = new Allocations(allocationsNode);
                 IDManager.SetID(allocationsIDRef_, ob);
             }
             else if (allocationsNode.Attributes["href"] != null)
             {
                 allocationsIDRef_ = allocationsNode.Attributes["href"].Value;
             }
             else
             {
                 allocations_ = new Allocations(allocationsNode);
             }
         }
         else
         {
             allocations_ = new Allocations(allocationsNode);
         }
     }
     
 
     XmlNodeList partyNodeList = xmlNode.SelectNodes("party");
     
     if (partyNodeList != null)
     {
         this.party_ = new List<Party>();
         foreach (XmlNode item in partyNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     partyIDRef_ = item.Attributes["id"].Value;
                     party_.Add(new Party(item));
                     IDManager.SetID(partyIDRef_, party_[party_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     partyIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 party_.Add(new Party(item));
                 }
             }
             else
             {
                 party_.Add(new Party(item));
             }
         }
     }
     
 
     XmlNodeList accountNodeList = xmlNode.SelectNodes("account");
     
     if (accountNodeList != null)
     {
         this.account_ = new List<Account>();
         foreach (XmlNode item in accountNodeList)
         {
             if (item.Attributes["href"] != null || item.Attributes["id"] != null) 
             {
                 if (item.Attributes["id"] != null) 
                 {
                     accountIDRef_ = item.Attributes["id"].Value;
                     account_.Add(new Account(item));
                     IDManager.SetID(accountIDRef_, account_[account_.Count - 1 ]);
                 }
                 else if (item.Attributes["href"] != null)
                 {
                     accountIDRef_ = item.Attributes["href"].Value;
                 }
                 else
                 {
                 account_.Add(new Account(item));
                 }
             }
             else
             {
                 account_.Add(new Account(item));
             }
         }
     }
     
 
     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));
             }
         }
     }
     
 
 }
Exemple #19
0
        public CompressionActivity(XmlNode xmlNode)
        {
            XmlNodeList compressionTypeNodeList = xmlNode.SelectNodes("compressionType");

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

            foreach (XmlNode item in compressionTypeNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        compressionTypeIDRef = item.Attributes["id"].Name;
                        CompressionType ob = CompressionType();
                        IDManager.SetID(compressionTypeIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        compressionTypeIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        compressionType = new CompressionType(item);
                    }
                }
            }


            XmlNodeList replacementTradeIdentifierNodeList = xmlNode.SelectNodes("replacementTradeIdentifier");

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

            foreach (XmlNode item in replacementTradeIdentifierNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        replacementTradeIdentifierIDRef = item.Attributes["id"].Name;
                        TradeIdentifier ob = TradeIdentifier();
                        IDManager.SetID(replacementTradeIdentifierIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        replacementTradeIdentifierIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        replacementTradeIdentifier = new TradeIdentifier(item);
                    }
                }
            }


            XmlNodeList originatingTradeIdentifierNodeList = xmlNode.SelectNodes("originatingTradeIdentifier");

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


            XmlNodeList replacementTradeIdNodeList = xmlNode.SelectNodes("replacementTradeId");

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

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


            XmlNodeList originatingTradeIdNodeList = xmlNode.SelectNodes("originatingTradeId");

            foreach (XmlNode item in originatingTradeIdNodeList)
            {
                if (item.Attributes["href"] != null || item.Attributes["id"] == null)
                {
                    if (item.Attributes["id"] != null)
                    {
                        originatingTradeIdIDRef = item.Attributes["id"].Name;
                        List <TradeId> ob = new List <TradeId>();
                        ob.Add(new TradeId(item));
                        IDManager.SetID(originatingTradeIdIDRef, ob);
                    }
                    else if (item.Attributes.ToString() == "href")
                    {
                        originatingTradeIdIDRef = item.Attributes["href"].Name;
                    }
                    else
                    {
                        originatingTradeId.Add(new TradeId(item));
                    }
                }
            }
        }
        public EventIdentifier(XmlNode xmlNode)
        {
            XmlNode correlationIdNode = xmlNode.SelectSingleNode("correlationId");

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


            XmlNode sequenceNumberNode = xmlNode.SelectSingleNode("sequenceNumber");

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


            XmlNode tradeIdentifierNode = xmlNode.SelectSingleNode("tradeIdentifier");

            if (tradeIdentifierNode != null)
            {
                if (tradeIdentifierNode.Attributes["href"] != null || tradeIdentifierNode.Attributes["id"] != null)
                {
                    if (tradeIdentifierNode.Attributes["id"] != null)
                    {
                        tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["id"].Value;
                        TradeIdentifier ob = new TradeIdentifier(tradeIdentifierNode);
                        IDManager.SetID(tradeIdentifierIDRef_, ob);
                    }
                    else if (tradeIdentifierNode.Attributes["href"] != null)
                    {
                        tradeIdentifierIDRef_ = tradeIdentifierNode.Attributes["href"].Value;
                    }
                    else
                    {
                        tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
                    }
                }
                else
                {
                    tradeIdentifier_ = new TradeIdentifier(tradeIdentifierNode);
                }
            }
        }