Removes the route specified by the path pattern.
169290
public void removePathPattern(String pathPattern) {
		for (MethodlessRouter<T> router : routers.values()) {
			router.removePathPattern(pathPattern);
		}
		anyMethodRouter.removePathPattern(pathPattern);
	}
20695
def delete(self):
        
        if self in self._parent.vlan_interface:
            self._parent.data['vlanInterfaces'] = [
                v for v in self._parent.vlan_interface
                if v != self]
            self.update()
            for route in self._parent._engine.routing:
                if route.to_delete:
                    route.delete()
605020
def remove(self):
        
        for cgroup in self.paths:
            remove_cgroup(cgroup)

        del self.paths
        del self.per_subsystem
182661
def _cleanup(path: str) -> None:
    """"""
    if os.path.isdir(path):
        shutil.rmtree(path)
135100
public boolean remove(String path) {
        jsonStore.clear();
        return JSONPath.remove(jsonObject, checkPath(path));
    }
878159
public static String removeIndexFromPath(String path)
   {
      if (path.endsWith("]"))
      {
         int index = path.lastIndexOf('[');
         if (index != -1)
         {
            return path.substring(0, index);
         }
      }
      return path;
   }
523538
def destroy(self):
        
        self.stop()
        if self.base_pathname is not None:
            self._robust_remove(self.base_pathname)
37338
private void removeTrail() {
        int last = this.size - 1;
        while (last >= 0 && this.arr[last] == this.blankElement) {
            last--;
        }
        this.size = last + 1;
    }
32418
public static void delete(@NotNull String path, @NotNull Handler handler) {
        staticInstance().delete(prefixPath(path), handler);
    }
703103
def clear(self):
        '''
        
        '''
        if os.path.exists(self.path):
            os.remove(self.path)
564402
def remove(parent, idx):
  """"""
  if isinstance(parent, dict):
    del parent[idx]
  elif isinstance(parent, list):
    del parent[int(idx)]
  else:
    raise JSONPathError("Invalid path for operation")
1102417
def purge(path: str, pattern: str) -> None:
    
    for f in find(pattern, path):
        log.info("Deleting {}", f)
        os.remove(f)
646625
public void removeServlet(String name, String pathSpec,
      Class<? extends HttpServlet> clazz) {
    if(clazz == null) {
       return;
    }

    //remove the filters from filterPathMapping
    ServletHandler servletHandler = webAppContext.getServletHandler();
    List<FilterMapping> newFilterMappings = new ArrayList<FilterMapping>();

    //only add the filter whose pathSpec is not the to-be-removed servlet
    for(FilterMapping mapping: servletHandler.getFilterMappings()) {
      for(String mappingPathSpec: mapping.getPathSpecs()) {
        if(!mappingPathSpec.equals(pathSpec)){
          newFilterMappings.add(mapping);
        }
      }
    }
  
    servletHandler.setFilterMappings(newFilterMappings.toArray(new FilterMapping[newFilterMappings.size()]));

    removeInternalServlet(name, pathSpec, clazz);
  }
52776
def remove_path_from_sys_path(self):
        """"""
        for path in self.path + self.project_path:
            while path in sys.path:
                sys.path.remove(path)
634938
def remove(self, path):
        

        entry = self.find(path)

        if not entry:
            raise ValueError("%s does not exists" % path)

        if entry.type == 'root storage':
            raise ValueError("can no remove root entry")

        if entry.type == "storage" and not entry.child_id is None:
            raise ValueError("storage contains children")

        entry.pop()

        # remove stream data
        if entry.type == "stream":
            self.free_fat_chain(entry.sector_id, entry.byte_size < self.min_stream_max_size)

        self.free_dir_entry(entry)
1169557
function reset(route) {

		// Resolve module location from given path
		const filename = _require.resolve(route);

		// Load it into memory
		_require(filename);

		// Remove all children from memory, recursively
		shidu(filename);

		// Remove module from memory as well
		delete _require.cache[filename];

		// Return exports value
		return _require(filename);
	}
445991
function removeExtension(path) {
  let leadingDot, endSlash = path.lastIndexOf('/');

  if (endSlash > -1) {
    leadingDot = path.indexOf('.', endSlash);
  } else {
    leadingDot = path.indexOf('.');
  }

  if (leadingDot > -1) {
    path = path.substr(0, leadingDot);
  }
  return path;
}