Returns a copy of this dependency path that has the provided related
appended to the end of its path sequence.
554741
public SimpleDependencyPath extend(DependencyRelation relation) {
        SimpleDependencyPath copy = copy();
        // Figure out which node is at the end of our path, and then add the new
        // node to the end of our nodes
        DependencyTreeNode last = last(); 
        copy.nodes.add((relation.headNode().equals(last)) 
                       ? relation.dependentNode() : relation.headNode());
        copy.path.add(relation);
        return copy;
    }
147205
def path(self):
        
        path = self.__prefix
        if self is not self.over:
            path = self.over.path + path
        return path
591900
def inheritance_lookup_path
      path = [self]
      until path.last == inheritable_root_controller
        path << path.last.superclass
      end
      path.collect(&:controller_path)
    end
692247
public function getRelativePath()
    {
        $templates = $this->config['directories']['templates'];

        $extension = $this->config['templates']['extension'];

        return $templates . '/' . $this->getFilename($extension);
    }
127265
void advance(SimpleDependencyPath path) {
        if (path.length() >= maxPathLength)
            return;

        // Get the last node and last relation to decide how to expand.
        DependencyRelation lastRelation = path.lastRelation();
        DependencyTreeNode last = path.last(); 
        
        // Expand all of the possible relations from the last node, creating a
        // new path for each, except if the relation is the one that generated
        // this path.
        for (DependencyRelation rel : last.neighbors()) {
            // Skip re-adding the current relation
            if (lastRelation.equals(rel) || !acceptor.accept(rel))
                continue;
            SimpleDependencyPath extended = path.extend(rel);
            frontier.offer(extended);
        }
    }
40624
public static File getRelativePath(final File basePath, final File refPath) {
        if (!basePath.toPath().getRoot().equals(refPath.toPath().getRoot())) {
            return refPath;
        }
        return basePath.toPath().getParent().relativize(refPath.toPath()).toFile();
    }
1248926
function getRelativePath (req) {
  if (!req.swagger.api.basePath) {
    return req.path;
  }
  else {
    return req.path.substr(req.swagger.api.basePath.length);
  }
}
1250582
def path(self):
        ""
        prefix = ()
        if self.parent:
            prefix = self.parent.path

        if self.id_or_name:
            return prefix + (self.kind, self.id_or_name)

        return prefix + (self.kind,)
964980
def get_path(self):
        
        path = deque()
        __, node = self.get_focus()
        while not node.is_root():
            stats = node.get_value()
            path.appendleft(hash(stats))
            node = node.get_parent()
        return path
342378
function buildDependencyPaths(self, context) {
  var dependencies = {};

  context.__dependencyPaths__.forEach(function (p) {
    var dep = new DependencyFile(p, self.environment.stat(p).mtime,
                                 self.environment.getFileDigest(p));
    dependencies[JSON.stringify(dep)] = dep;
  });

  _.forEach(context.__dependencyAssets__, function (p) {
    var dep, asset;

    if (p === self.pathname) {
      dep = new DependencyFile(p, self.environment.stat(p).mtime,
                               self.environment.getFileDigest(p));
      dependencies[JSON.stringify(dep)] = dep;
      return;
    }

    asset = self.environment.findAsset(p, { bundle: false });

    if (asset) {
      asset.dependencyPaths.forEach(function (dep) {
        dependencies[JSON.stringify(dep)] = dep;
      });
    }
  });

  prop(self, '__dependencyPaths__', _.values(dependencies));
}
1104819
def path (self):
        
        if not self.path_:
            if self.action_:
                p = self.action_.properties ()
                (target_path, relative_to_build_dir) = p.target_path ()

                if relative_to_build_dir:
                    # Indicates that the path is relative to
                    # build dir.
                    target_path = os.path.join (self.project_.build_dir (), target_path)

                # Store the computed path, so that it's not recomputed
                # any more
                self.path_ = target_path

        return os.path.normpath(self.path_)
1000116
def getRelativePath(basepath, path):
    """"""
    basepath = splitpath(os.path.abspath(basepath))
    path = splitpath(os.path.abspath(path))
    afterCommon = False
    for c in basepath:
        if afterCommon or path[0] != c:
            path.insert(0, os.path.pardir)
            afterCommon = True
        else:
            del path[0]
    return os.path.join(*path)
1124493
public DependencyInfo getDependencyInfo(final String sourceRelativeName, final String includePathIdentifier) {
    DependencyInfo dependInfo = null;
    final DependencyInfo[] dependInfos = (DependencyInfo[]) this.dependencies.get(sourceRelativeName);
    if (dependInfos != null) {
      for (final DependencyInfo dependInfo2 : dependInfos) {
        dependInfo = dependInfo2;
        if (dependInfo.getIncludePathIdentifier().equals(includePathIdentifier)) {
          return dependInfo;
        }
      }
    }
    return null;
  }
407824
public List<String> getDependencyPath(int nodeIndex, int rootIndex) {
    TreeGraphNode node = getNodeByIndex(nodeIndex);
    TreeGraphNode rootTree = getNodeByIndex(rootIndex);
    return getDependencyPath(node, rootTree);
  }
1213678
@Nullable
  static SourceFile getRelativePath(String baseFilePath, String relativePath) {
    return SourceFile.fromPath(
        FileSystems.getDefault().getPath(baseFilePath).resolveSibling(relativePath).normalize(),
        UTF_8);
  }
1308468
def get_rendered_transform_path_relative(self, relative_transform_ref):
        
        path = self.transform_path
        parent = self.parent

        while parent is not None and parent is not relative_transform_ref:
            path = "{0}/{1}".format(parent.transform_path, path)
            parent = parent.parent

        return path
1257996
public int getDimension(DependencyPath path) {
        String endToken = path.last().word();

        // Extract out how the current word is related to the last word in the
        // path.  
        String relation = path.getRelation(path.length() - 1);
        return getDimensionInternal(endToken + "+" + relation);
    }