TypeScript graphlib.alg类代码示例

export function generateOrder(proj: project.Project) {
	const inputGraph = new Graph<FileInput, {}>({ directed: true });

	for (const file of proj.files) {
		inputGraph.setNode(file.filename, {
			file,
			groupName: undefined
		});
	}

	for (const file of proj.files) {
		for (const dependency of file.dependencies) {
			inputGraph.setEdge(file.filename, dependency.filename);
		}
	}

	const acyclicGraph = new Graph<FileGroup, {}>({ directed: true });

	for (const group of alg.tarjan(inputGraph)) {
		acyclicGraph.setNode(group[0], {
			filenames: group
		});

		for (const member of group) {
			inputGraph.node(member).groupName = group[0];
		}
	}

	for (const filename of inputGraph.nodes()) {
		const groupName = inputGraph.node(filename).groupName;
		for (const edge of inputGraph.inEdges(filename)) {
			const otherGroup = inputGraph.node(edge.w).groupName;
			if (groupName !== otherGroup) acyclicGraph.setEdge(groupName, otherGroup);
		}
	}

	const order = alg.topsort(acyclicGraph);
	let index = 0;

	for (const groupName of order) {
		const group = acyclicGraph.node(groupName);
		const component: file.SourceFile[] = [];
		const cyclic = group.filenames.length !== 1;
		for (const filename of group.filenames) {
			const file = inputGraph.node(filename).file;
			if (cyclic) {
				file.hasCircularDependencies = true;
				file.connectedComponent = component;
				component.push(file);
			} else {
				file.hasCircularDependencies = false;
			}
			file.orderIndex = index++;
			proj.orderFiles.push(file);
		}
	}
}

function createDependencyGraphFromSchema(data : model.DependencyGraphSchema,
                            repos : Map<string, model.RepositorySchema>) : Graphlib.Graph<model.RepositorySchema, void> {

    let options = { directed: true, compound: false, multigraph: false };
    let graph : Graphlib.Graph<model.RepositorySchema, void> = new Graphlib.Graph(options);

    data.repos.forEach((repoName : string) => {
        let repo = repos.get(repoName);
        if(!repo) {
            throw new Error(`cannot create dependency graph, repository ${repoName} not found`);
        }
        graph.setNode(repoName, repo);
    });

    data.dependencies.forEach((dependency : model.Dependency) => {
        if(repos.has(dependency.up) && repos.has(dependency.down)) {
            graph.setEdge(dependency.up, dependency.down);
        }
    });

    if(!Graphlib.alg.isAcyclic(graph)) {
        throw new Error('cannot create dependency graph, contains circular dependencies: ' + JSON.stringify(data));
    }

    return graph;
}

    static fromSchemas(dependencies : Array<model.Dependency>, jobs : Array<model.BuildSchema>) : PipelineGraph {

        let options = { directed: true, compound: false, multigraph: false };
        let graph : Graphlib.Graph<model.BuildSchema, void> = new Graphlib.Graph(options);

        jobs.forEach((job : model.BuildSchema) => {
            graph.setNode(job._id, job);
        });

        let jobsByRepo : Map<string, model.BuildSchema> = new Map();
        jobs.forEach(job => jobsByRepo.set(job.repo, job));

        dependencies.forEach((dependency : model.Dependency) => {
            if(jobsByRepo.has(dependency.up) && jobsByRepo.has(dependency.down)) {
                graph.setEdge(jobsByRepo.get(dependency.up)._id, jobsByRepo.get(dependency.down)._id);
            }
        });

        if(!Graphlib.alg.isAcyclic(graph)) {
            throw new Error('pipeline graph contains circular dependencies:' + JSON.stringify(Graphlib.json.write(graph)));
        }

        if(graph.sources().length > 1) {
            throw new Error('pipeline graph has more than one source nodes: ' + JSON.stringify(Graphlib.json.write(graph)));
        }

        let pipelineGraph = new PipelineGraph();
        pipelineGraph._graph = graph;
        pipelineGraph._dependencies = dependencies;
        pipelineGraph._builds = jobs;

        return pipelineGraph;

    }

function test_graph() {
  var g = new graphlib.Graph({
    compound: true,
    directed: true,
    multigraph: true
  });
  g.setEdge('a', 'b');
  g.setEdge('a', 'b', 1.023, 'test');
  g.setEdge({ v: 'a', w: 'b', name: 'test' }, 1.023);
  g.hasEdge('a', 'b', 'test');
  g.hasEdge({ v: 'a', w: 'b', name: 'test' });
  g.removeEdge('a', 'b', 'test');
  g.removeEdge({ v: 'a', w: 'b', name: 'test' });

  g.edge('a', 'b', 'test');
  g.edge({v: 'a', w: 'b', name: 'test'});
  g.setDefaultNodeLabel({});
  g.setDefaultNodeLabel(() => 42);
  g.setDefaultEdgeLabel({});
  g.setDefaultEdgeLabel(() => 'e42');
  g.setNodes(['a', 'b', 'c'], 42);
  g.setParent('d', 'a');
  g.setParent('d');
  g.parent('d');
  g.children('a');
  g.filterNodes(v => true);
  g.setPath(['a', 'b', 'c'], 42);

  graphlib.json.read(graphlib.json.write(g));

  graphlib.alg.dijkstra(g, 'a', e => g.edge(e));
  graphlib.alg.dijkstraAll(g, e => g.edge(e));
  graphlib.alg.dijkstraAll(g);

  graphlib.alg.findCycles(g);
  graphlib.alg.isAcyclic(g);
  graphlib.alg.prim(g, e => g.edge(e));
  graphlib.alg.tarjan(g);
  graphlib.alg.topsort(g);
  graphlib.alg.preorder(g, g.nodes());
  graphlib.alg.postorder(g, g.nodes());
}

function test_graph() {
  var g = new graphlib.Graph();
  g.setEdge('a', 'b');
  g.setEdge('a', 'b', 1.023);

  g.edge('a', 'b');
  g.edge({v: 'a', w: 'b'});

  graphlib.json.read(graphlib.json.write(g));

  graphlib.alg.dijkstra(g, 'a', e => g.edge(e));
  graphlib.alg.dijkstraAll(g, e => g.edge(e));
  graphlib.alg.dijkstraAll(g);

  graphlib.alg.findCycles(g);
  graphlib.alg.isAcyclic(g);
  graphlib.alg.prim(g, e => g.edge(e));
  graphlib.alg.tarjan(g);
  graphlib.alg.topsort(g);
}

    private nodesSortedByDistance(graph : Graphlib.Graph<any, any>, source : any) : Array<any> {
        let distances = Graphlib.alg.dijkstra(graph, source);
        let nodes:Array<any> = [];

        for (var prop in distances) {
            if (distances.hasOwnProperty(prop)) {
                let distanceToSource = distances[prop].distance;
                if(distanceToSource == Number.POSITIVE_INFINITY) {
                    throw new Error('pipeline graph contains unconnected nodes: ' + Graphlib.Json.write(graph));
                }
                nodes.push({nodeId : prop, distance: distanceToSource})
            }
        }

        let sortByDistance = (node1, node2) => { return node1.distance - node2.distance };

        let sortedNodes = nodes.sort(sortByDistance);

        return sortedNodes.map((item) => {return item.nodeId});
    }

    createSubgraph(repo : model.RepositorySchema) : DependencyGraph {

        let newGraph = cloneGraph(this._graph);

        let dijkstraAlgResult = Graphlib.alg.dijkstra(this._graph, repo.name); // or floydWarshall might be faster

        let isValidNode = node => {return dijkstraAlgResult.hasOwnProperty(node) && dijkstraAlgResult[node].distance  != "Infinity"};

        this._graph.nodes().forEach((node) => {
            if(!isValidNode(node)) {
                newGraph.removeNode(node);
            }
        });

        let newDependencyGraph = new DependencyGraph();
        newDependencyGraph._graph = newGraph;
        newDependencyGraph._repos = newGraph.nodes().map(repoId => {return newGraph.node(repoId)});
        newDependencyGraph._dependencies = newGraph.edges().map((edge) => { return {up : edge.v, down : edge.w} });

        return newDependencyGraph;
    }