private void AddEdge(Topology.IGP.Link.Link Edge)
            {
                if (!this.Links.ContainsKey(Edge.SourceNode))
                {
                    this.Links.Add(Edge.Id, Edge);

                    if (Edge.OperationalStatus)
                    {
                        var forwardEdge  = new TaggedEdge <string, Topology.IGP.Link.Link>(Edge.SourceNode, Edge.TargetNode, Edge);
                        var backwardEdge = new TaggedEdge <string, Topology.IGP.Link.Link>(Edge.TargetNode, Edge.SourceNode, Edge);

                        this.Graph.AddEdge(forwardEdge);
                        this.Graph.AddEdge(backwardEdge);

                        this.EdgeCost.Add(forwardEdge, Convert.ToDouble(Edge.Rtt));
                        this.EdgeCost.Add(backwardEdge, Convert.ToDouble(Edge.Rtt));
                    }
                }
            }
        public void LoadIGPTopology(Topology.IGP.Topology topology)
        {
            topology.Clear();

            foreach (var record in GetIGPTopology())
            {
                var path = record.Values["p"].As <IPath>();

                Dictionary <long, string> nodeDatabaseIds = new Dictionary <long, string>();
                Dictionary <long, bool>   pseudonodes     = new Dictionary <long, bool>();

                foreach (var node in path.Nodes)
                {
                    string igpRouterIdentifier = TryGetNodePropertyAsString(node, "IGP_Router_Identifier");

                    if (!string.IsNullOrWhiteSpace(igpRouterIdentifier))
                    {
                        nodeDatabaseIds.Add(node.Id, igpRouterIdentifier);

                        Topology.Node.Node n = new Topology.Node.Node()
                        {
                            IgpRouterIdentifier = igpRouterIdentifier,
                            Psn = TryGetNodeProperty <int>(node, "psn"),
                            IPv4RouterIdentifier = TryGetNodePropertyAsString(node, "IPv4_Router_Identifier"),
                            NodeName             = TryGetNodePropertyAsString(node, "Node_Name"),
                            FirstSeen            = TryGetNodeProperty <long>(node, "First_Seen"),
                            LastEvent            = TryGetNodeProperty <long>(node, "Last_Event"),
                            OperationalStatus    = true
                        };

                        if (Regex.IsMatch(igpRouterIdentifier, @"^\d{12}$") && n.Psn == 0)
                        {
                            n.IsPseudonode = false;
                            n.NodeCost     = 1;

                            pseudonodes.Add(node.Id, n.IsPseudonode);
                        }
                        else
                        {
                            if (Regex.IsMatch(igpRouterIdentifier, @"^\d{12}\d+$") && n.Psn != 0)
                            {
                                n.IsPseudonode = true;
                                n.NodeCost     = 0;

                                pseudonodes.Add(node.Id, n.IsPseudonode);
                            }
                        }

                        topology.Update(n);
                    }
                }

                foreach (var link in path.Relationships)
                {
                    Topology.IGP.Link.Link l = new Topology.IGP.Link.Link()
                    {
                        SourceNode                     = nodeDatabaseIds[link.StartNodeId],
                        TargetNode                     = nodeDatabaseIds[link.EndNodeId],
                        Asn                            = TryGetRelProperty <long>(link, "asn"),
                        MaximumLinkBandwidth           = TryGetRelProperty <double>(link, "Maximum_Link_Bandwidth"),
                        MaximumReservableLinkBandwidth = TryGetRelProperty <double>(link, "Maximum_Reservable_Bandwidth"),
                        UnreservedBandwidth            = TryGetRelPropertyAsArray <double>(link, "Unreserved_Bandwidth"),
                        Rtt                            = TryGetRelProperty <long>(link, "rtt"),
                        IPv4InterfaceAddress           = TryGetRelPropertyAsString(link, "IPv4_Interface_Address"),
                        SharedRiskLinkGroups           = TryGetRelPropertyAsArray <long>(link, "Shared_Risk_Link_Groups"),
                        FirstSeen                      = TryGetRelProperty <long>(link, "First_Seen"),
                        LastEvent                      = TryGetRelProperty <long>(link, "Last_Event"),
                        OperationalStatus              = true
                    };

                    if (pseudonodes[link.StartNodeId] || pseudonodes[link.EndNodeId])
                    {
                        l.LinkCost = 0.5;
                    }
                    else
                    {
                        l.LinkCost = 1;
                    }

                    topology.Update(l);
                }
            }
        }