Try to unlink this path. If it doesn't exist, no error is returned. Returns
        a boolean indicating whether the path was really unlinked.
15181
def try_unlink (self):
        
        try:
            self.unlink ()
            return True
        except OSError as e:
            if e.errno == 2:
                return False # ENOENT
            raise
1315729
def remove_from_pythonpath(self, path):
        """"""
        pathlist = self.get_pythonpath()
        if path in pathlist:
            pathlist.pop(pathlist.index(path))
            self.set_pythonpath(pathlist)
            return True
        else:
            return False
152828
function unlinkPrevious(callback) {
  fs.unlink(path.resolve(yeoman, 'bootstrap-less'), function(err) {
    if (err) return console.log('unlink error:', err);
    console.log('Previous version of yeoman-bootstrap successfully unlinked...');
    return callback();
  });
}
1122888
def unregister_path(self, path):
        

        if not path in self:
            raise umbra.exceptions.PathExistsError("{0} | '{1}' path isn't registered!".format(
                self.__class__.__name__, path))

        del (self.__paths[path])
        return True
730919
def remove(path):
    
    if not os.path.exists(path):
        return

    if os.path.isdir(path):
        return shutil.rmtree(path)

    if os.path.isfile(path):
        return os.remove(path)
552511
private final void _tryUnlink() {
        if (0 >= _cursorCount && _state == LOGICALLY_UNLINKED) {
            _previousLink._nextLink = _nextLink;
            _nextLink._previousLink = _previousLink;
            _previousLink = null;
            _nextLink = null;
            // Defect 240039
            //_parent = null;
            _state = PHYSICALLY_UNLINKED;
        }
    }
1261229
public function unlink($path)
    {
        if (false === self::cache()->get($path)) {
            return false;
        }

        self::cache()->delete($path);

        return true;
    }
1136970
def remove_path(path):
    """"""
    if path is None or not os.path.exists(path):
        return
    if platform.system() == 'Windows':
        # Need to have write permission before deleting the file.
        os.chmod(path, stat.S_IWRITE)
    try:
        if os.path.isdir(path):
            shutil.rmtree(path)
        elif os.path.isfile(path):
            shutil.os.remove(path)
    except OSError:
        logger.exception("Could not remove path: %s" % 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)
679819
public final boolean unlink()
    {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.entry(this, tc, "unlink", _positionString());

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "cursor count = " + _cursorCount);

        boolean unlinked = false;
        LinkedList parent = _parent;
        if (null != parent)
        {
            synchronized(parent)
            {
                if (LinkState.LINKED == _state)
                {
                    _state = LinkState.LOGICALLY_UNLINKED;
                    _tryUnlink();
                    unlinked = true;
                }
                else
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) SibTr.debug(this, tc, "unlink while " + _state);
                }
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) SibTr.exit(this, tc, "unlink", new Object[] { Boolean.valueOf(unlinked), _positionString()});
        return unlinked;
    }
452564
public static base_response unlink(nitro_service client, sslcertkey resource) throws Exception {
		sslcertkey unlinkresource = new sslcertkey();
		unlinkresource.certkey = resource.certkey;
		return unlinkresource.perform_operation(client,"unlink");
	}
1302433
private E unlinkLast() {
        // assert lock.isHeldByCurrentThread();
        Node<E> l = last;
        if (l == null)
            return null;
        Node<E> p = l.prev;
        E item = l.item;
        l.item = null;
        l.prev = l; // help GC
        last = p;
        if (p == null)
            first = null;
        else
            p.next = null;
        --count;
        notFull.signal();
        return item;
    }
1083696
def unlink(self):
        
        links = self.registry.get(self.source)
        if self in links:
            links.pop(links.index(self))
303504
@Override
    public Promise<Void> unlink(String link) {
        return adapter.toPromise(handler -> vertx.fileSystem().unlink(link, handler));
    }
870358
def forget(self, key):
        
        path = self._path(key)

        if os.path.exists(path):
            os.remove(path)

            return True

        return False
762225
public function unlink($path)
	{
		if(isset(static::$pointer_tree[$path_to]))
		{
			if(is_resource(static::$pointer_tree[$path_to]))
				fclose(static::$pointer_tree[$path_to]);
			
			unset(static::$pointer_tree[$path_to]);
		}
		
		return true;
	}
317779
def _checkpath(self, path):
        
        if path.startswith("/") or ".." in path or path.strip() != path:
            raise NotFoundException()