The paths for each essential cycle.

@return array of vertex paths
554154
public int[][] paths() {
        final int[][] paths = new int[size()][];
        for (int i = 0; i < paths.length; i++)
            paths[i] = essential.get(i).path();
        return paths;
    }
1041660
public function allPsr0SourcePaths()
    {
        $autoloadPsr0Paths = array();
        foreach ($this->autoloadPsr0() as $namespace => $paths) {
            $autoloadPsr0Paths = array_merge($autoloadPsr0Paths, $paths);
        }

        return $autoloadPsr0Paths;
    }
649984
public List vertexList() {
        List vertices = new ArrayList(edgeSet().size());

        Object startVertex = vertexSet().iterator().next();

        Object vertex = startVertex;
        Object previousVertex = null;
        Object nextVertex = null;

        while (nextVertex != startVertex) {
            assert (degreeOf(vertex) == 2);
            List edges = edgesOf(vertex);

            vertices.add(vertex);

            Edge edge = (Edge) edges.get(0);
            nextVertex = edge.oppositeVertex(vertex);

            if (nextVertex == previousVertex) {
                edge = (Edge) edges.get(1);
                nextVertex = edge.oppositeVertex(vertex);
            }

            previousVertex = vertex;
            vertex = nextVertex;

        }

        return vertices;
    }
106640
public function getMap()
    {
        $vertices = array();
        foreach ($this->vertices as $vertex) {
            $vertices[$vertex->getId()] = $vertex;
        }
        return $vertices;
    }
440233
public function getDescentPaths($id)
    {
        list($start_vertex, $graph) = $this->getDescentGraph($id);

        if (!$graph) {
            return [];
        }

        $resolver = new PathResolver($graph);

        return $resolver->resolvePaths($start_vertex);
    }
535731
public function getRoutesPatterns()
	{
		$patterns = [];
		$rows = $this->getRoutes();
		if ($rows) foreach ($rows as $route) {
		    $patterns[] = $route->getPattern();
		}
		return $patterns;
	}
368254
public function getPaths() : array
    {
        $templatePaths = [];

        $paths = $this->template->getFinder()->getPaths();
        $hints = $this->template->getFinder()->getHints();

        foreach ($paths as $path) {
            $templatePaths[] = new TemplatePath($path);
        }

        foreach ($hints as $namespace => $path) {
            $templatePaths[] = new TemplatePath($namespace, $path);
        }

        return $templatePaths;
    }
1222003
public function getPaths() {
		
		if ($this->lastUrlDisabled) {
			$newPaths = $this->paths;
			end($newPaths)->url = NULL;
			return $newPaths;
		} else {
			return $this->paths;
		}
		
	}
450063
public Map relevantCycles() {
        Map result = new HashMap();
        //minimize();

        for (SimpleCycleBasis subgraphBase : subgraphBases) {
            SimpleCycleBasis cycleBasis = subgraphBase;
            result.putAll(cycleBasis.relevantCycles());
        }

        return result;
    }
1230923
protected static function getAllPaths()
    {
        $paths = Cache::read('paths', 'static_pages');

        if (empty($paths)) {
            //Adds all plugins to paths
            $paths = collection(Plugin::all())
                ->map(function ($plugin) {
                    return self::getPluginPath($plugin);
                })
                ->filter(function ($path) {
                    return file_exists($path);
                })
                ->toList();

            //Adds APP to paths
            array_unshift($paths, self::getAppPath());

            Cache::write('paths', $paths, 'static_pages');
        }

        return $paths;
    }
1349121
public Point3d[] getVertices() {
        Point3d[] vtxs = new Point3d[numVertices];
        for (int i = 0; i < numVertices; i++) {
            vtxs[i] = pointBuffer[vertexPointIndices[i]].pnt;
        }
        return vtxs;
    }
155332
def find_all_paths(G, start, end, path=[]):
    
    path = path + [start]
    if start == end:
        return [path]
    if start not in G.vertices:
        raise GraphInsertError("Vertex %s doesn't exist." % (start,))
    if end not in G.vertices:
        raise GraphInsertError("Vertex %s doesn't exist." % (end,))
    paths = []
    for vertex in G.vertices[start]:
        if vertex not in path:
            newpaths = find_all_paths(G, vertex, end, path)
            for newpath in newpaths:
                paths.append(newpath)
    return paths
1219941
public function getGateways()
    {
        $gateways = [];
        foreach ($this->_gateways as $id => $gateway) {
            $gateways[$id] = $this->getGateway($id);
        }
        return $gateways;
    }
995517
public function getRoutes()
    {
        $out = [];
        foreach($this->routes as $route) {
            $out[] = $route;
        }

        foreach ($this->children as $child) {
            foreach ($child->getRoutes() as $route) {
                $out[] = $route;
            }
        }

        return $out;
    }
1365342
public function getApiPaths()
    {
        $paths = [];
        if ($apis = $this->get('apis')) {
            foreach ($apis as $api) {
                if (isset($api['path'])) {
                    $paths[] = $api['path'];
                }
            }
        }
        return $paths;
    }
529351
public function getRounds()
    {
        $this->_ensureRounds();

        foreach ($this->_rounds as $roundId => $roundData) {
            if (! isset($this->_roundObjects[$roundId])) {
                $this->_roundObjects[$roundId] = $this->tracker->createTrackClass('Round', $roundData);
            }
        }
        return $this->_roundObjects;
    }
925142
public function getReleaseDirs() {
        $dirs = array();
        foreach ($this->roadMap as $road) {
            /* @var $road SourceRoad */
            $release_dir = $road->getReleaseDir();
            if (empty($release_dir)) {
                continue;
            }
            if (!$release_dir->exists()) {
                if (!$release_dir->mkdirs()) {
                    continue;
                }
            }
            array_push($dirs, $release_dir);
        }
        return $dirs;
    }