Пример #1
0
        private bool TraverseDfs(
            [NotNull] DfsNode vertexNode,
            ref int time,
            [NotNull] IDictionary <TVertex, DfsNode> visitedNodes,
            [NotNull] Predicate <IDfsNode> handleVertexVisited,
            [NotNull] Predicate <IDfsNode> handleVertexCompleted,
            [NotNull] Func <IDfsNode, IDfsNode, bool> handleCycle)
        {
            Assert.NotNull(vertexNode);
            Assert.NotNull(visitedNodes);
            Assert.NotNull(handleVertexCompleted);
            Assert.NotNull(handleVertexVisited);
            Assert.NotNull(handleCycle);

            visitedNodes.Add(vertexNode.Vertex, vertexNode);
            vertexNode.EntryTime = time++;

            if (!handleVertexVisited(vertexNode))
            {
                return(false);
            }

            var breakRequested = false;

            foreach (var edge in GetEdges(vertexNode.Vertex))
            {
                if (breakRequested)
                {
                    break;
                }

                if (!visitedNodes.TryGetValue(edge.ToVertex, out var visitedNode))
                {
                    visitedNode = new DfsNode(edge)
                    {
                        Parent = vertexNode
                    };

                    breakRequested =
                        !TraverseDfs(visitedNode, ref time, visitedNodes, handleVertexVisited, handleVertexCompleted,
                                     handleCycle);
                }
                else if ((IsDirected || visitedNode != vertexNode.Parent) &&
                         visitedNode.EntryTime <= vertexNode.EntryTime)
                {
                    if (!handleCycle(vertexNode, visitedNode))
                    {
                        breakRequested = true;
                    }
                }
            }

            vertexNode.ExitTime = time++;
            if (!handleVertexCompleted(vertexNode))
            {
                breakRequested = true;
            }

            return(!breakRequested);
        }
Пример #2
0
        public List <DFSNode> GetDFSNodes()
        {
            List <DFSNode> dfsNodes = new List <DFSNode>();

            foreach (DfsNode dfsNodeInformation in DfsNode.GetInstances())
            {
                DFSNode dfsNodeData = new DFSNode(dfsNodeInformation.Name, dfsNodeInformation.Root, dfsNodeInformation.Description, dfsNodeInformation.Timeout);

                dfsNodes.Add(dfsNodeData);
            }

            return(dfsNodes);
        }
Пример #3
0
        public List <DFSRoot> GetDFSRoots()
        {
            List <DFSRoot> dfsRoots = new List <DFSRoot>();

            foreach (DfsNode dfsNodeInformation in DfsNode.GetInstances())
            {
                if (dfsNodeInformation.Root)
                {
                    DFSRoot dfsRootData = new DFSRoot(dfsNodeInformation.Name, dfsNodeInformation.Description, dfsNodeInformation.Timeout);
                    dfsRoots.Add(dfsRootData);
                }
            }

            return(dfsRoots);
        }
Пример #4
0
        public List <DFSRoot> GetDFSNamespaces(string DFSRoot)
        {
            List <DFSRoot> dfsNamespace = new List <DFSRoot>();

            foreach (DfsNode dfsNodeInformation in DfsNode.GetInstances())
            {
                if (!dfsNodeInformation.Root)
                {
                    if (dfsNodeInformation.Name.Contains(DFSRoot))
                    {
                        DFSRoot dfsRootData = new DFSRoot(dfsNodeInformation.Name, dfsNodeInformation.Description, dfsNodeInformation.Timeout);
                        dfsNamespace.Add(dfsRootData);
                    }
                }
            }

            return(dfsNamespace);
        }
Пример #5
0
 public uint DFSCreateNode(string dfsDescription, string dfsPath, string dfsServerName, string dfsServerPath)
 {
     return(DfsNode.Create(dfsDescription, dfsPath, dfsServerName, dfsServerPath));
 }