start of the path.
11213
private static String getPath(String uri) {
        int offset = 0;
        if (uri.startsWith("http://")) {
            offset = "http://".length();
        } else if (uri.startsWith("https://")) {
            offset = "https://".length();
        }

        if (offset == 0) {
            return uri;
        } else {
            int firstSlash = uri.indexOf('/', offset);
            return -1 != firstSlash? uri.substring(firstSlash) : uri;
        }
    }
991115
protected StringBuilder getPath(StringBuilder path, int startIndex, boolean addPoint) {
		boolean simple = true;
		if (key != null) {
			if (addPoint && path.length() > 0) {
				path.insert(0, '.');
			}
			if (key instanceof Integer) {
				path.insert(0, ']');
				if (startIndex == 0) {
					path.insert(0, key);
				} else {
					path.insert(0, startIndex + (int) key);
				}
				path.insert(0, '[');
				simple = false;
			} else {
				path.insert(0, key);
			}
		}
		if (parent != null) {
			parent.getPath(path, startIndex, simple);
		}
		return path;
	}
760325
def walk_tree(start, attr):
    
    path = [start]
    for child in path:
        yield child
        idx = path.index(child)
        for grandchild in reversed(getattr(child, attr)):
            path.insert(idx + 1, grandchild)
474829
function (start, end, pos, complete) {
		var ret = [],
			i = start.length,
			startVal;

		if (pos === 1) { // land on the final path without adjustment points appended in the ends
			ret = complete;

		} else if (i === end.length && pos < 1) {
			while (i--) {
				startVal = parseFloat(start[i]);
				ret[i] =
					isNaN(startVal) ? // a letter instruction like M or L
						start[i] :
						pos * (parseFloat(end[i] - startVal)) + startVal;

			}
		} else { // if animation is finished or length not matching, land on right value
			ret = end;
		}
		return ret;
	}
1112751
public function start()
    {
        $routeType = $this->getType();
        if ($routeType == RouteType::NORMAL) {
            $this->typeNormal();
        }
        if ($routeType == RouteType::PATHINFO) {
            $this->typePathInfo();
        }
        if ($routeType == RouteType::MAP) {
            $this->typeMap();
        }
        if ($routeType == RouteType::SYMFONY) {
            $this->typeSymfony();
        }
        return true;
    }
839370
function (path, segment, translatedThreshold) {
		path.push(
			L,
			segment[segment.length - 1].plotX,
			translatedThreshold,
			L,
			segment[0].plotX,
			translatedThreshold
		);
	}
186647
def __path(self, path):
        
        if path.startswith(self.__prefix):
            return path

        return "{}{}".format(self.__prefix, path)
1211146
void initWithSingleTokenPath(String path) {
        this.path = path;
        this.index = 0;
        this.offset = 0;
        this.nextSplit = -1;
        this.token = path;
    }
324822
def register_path(self, path):
        
        self._paths.insert(0, os.path.abspath(path))
683173
def abspath(self, path):
        """"""
        if self.is_ssh(path):
            return path
        else:
            return os.path.abspath(path)
745999
public void curveStart()
    {
        double d0 = AbstractPoint.angle(P[start], P[start+3]);      // P0 -> P3
        double d1 = AbstractPoint.angle(P[start+3], P[start]);      // P3 -> P0
        double d2 = AbstractPoint.angle(P[start+3], P[start+2]);    // P3 -> P2
        double a1 = d1 - d2;
        double a2 = d0 + a1;
        double di = AbstractPoint.distance(P[start+3], P[start+2]);
        P[start+1] = AbstractPoint.move(P[start], a2, di);
    }
787246
public void setPath(List<? extends S> path, Direction1D direction) {
		this.path = path == null || path.isEmpty() ? null : new ArrayList<>(path);
		this.firstSegmentDirection = detectFirstSegmentDirection(direction);
	}
521973
def find_path(self, start, end, grid):
        
        start.g = 0
        start.f = 0
        return super(AStarFinder, self).find_path(start, end, grid)
401587
public void startPath(double x, double y) {
		Point2D endPoint = new Point2D();
		endPoint.x = x;
		endPoint.y = y;
		startPath(endPoint);
	}
908230
def path(self):
        """"""
        out = self.datetime.strftime("%Y-%m-%d")
        out += " "
        ssm = (
            self.datetime - self.datetime.replace(hour=0, minute=0, second=0, microsecond=0)
        ).total_seconds()
        out += str(int(ssm)).zfill(5)
        return out
45561
def initial_paths
        machine.events.transitions_for(object, :from => from_name, :guard => @guard).map do |transition|
          path = Path.new(object, machine, :target => to_name, :guard => @guard)
          path << transition
          path
        end
      end
1177059
def find_path(start, goal, neighbors_fnct, reversePath=False, heuristic_cost_estimate_fnct=lambda a, b: Infinite, distance_between_fnct=lambda a, b: 1.0, is_goal_reached_fnct=lambda a, b: a == b):
    """"""
    class FindPath(AStar):

        def heuristic_cost_estimate(self, current, goal):
            return heuristic_cost_estimate_fnct(current, goal)

        def distance_between(self, n1, n2):
            return distance_between_fnct(n1, n2)

        def neighbors(self, node):
            return neighbors_fnct(node)

        def is_goal_reached(self, current, goal):
            return is_goal_reached_fnct(current, goal)
    return FindPath().astar(start, goal, reversePath)