unlinks the shared memory
322204
def unlink(self):
        """"""
        if os.name == "posix":
            self.__linux_unlink__()
        elif os.name == "nt":
            self.__windows_unlink__()
        else:
            raise HolodeckException("Currently unsupported os: " + os.name)
518253
private void unlinkLast(Node<E> last, Node<E> prev) {
        // assert last != null;
        // assert prev != null;
        // assert last.item == null;
        for (Node<E> o = null, p = prev, q;;) {
            if (p.item != null || (q = p.prev) == null) {
                if (o != null && p.next != p && last.casPrev(prev, p)) {
                    skipDeletedSuccessors(p);
                    if (last.next == null &&
                        (p.prev == null || p.item != null) &&
                        p.next == last) {

                        updateHead(); // Ensure o is not reachable from head
                        updateTail(); // Ensure o is not reachable from tail

                        // Finally, actually gc-unlink
                        o.lazySetPrev(o);
                        o.lazySetNext(nextTerminator());
                    }
                }
                return;
            }
            else if (p == q)
                return;
            else {
                o = p;
                p = q;
            }
        }
    }
732350
public void unlink(Name name) {
    DirectoryEntry entry = remove(checkNotReserved(name, "unlink"));
    entry.file().unlinked();
  }
160263
def unlink(self, parameter):
        

        if not isinstance(parameter,list):
        # Make a list of one element
            parameter_list  = [parameter]
        else:
        # Make a copy to avoid tampering with the input
            parameter_list = list(parameter)
            
        for param in parameter_list:    
            if param.has_auxiliary_variable():
                param.remove_auxiliary_variable()

            else:

                with warnings.catch_warnings():

                    warnings.simplefilter("always", RuntimeWarning)

                    warnings.warn("Parameter %s has no link to be removed." % param.path, RuntimeWarning)
1156818
public void clearMemory() {
        zeroArray(k);
        k = null;
        zeroArray(n);
        n = null;
        zeroArray(e);
        e = null;
        zeroArray(d);
        d = null;
        zeroArray(dp);
        dp = null;
        zeroArray(dq);
        dq = null;
        zeroArray(qi);
        qi = null;
        zeroArray(p);
        p = null;
        zeroArray(q);
        q = null;
        zeroArray(t);
        t = null;
        zeroArray(x);
        x = null;
        zeroArray(y);
        y = null;
    }
1334536
def close(self):
        
        self._dll.JLINKARM_Close()

        if self._lock is not None:
            del self._lock
            self._lock = None

        return None
732024
@Override
    public final void releaseIfDiscardable() throws SevereMessageStoreException
    {
        boolean unlink = false; // flag so we can unlink outside sync block
        if (isStoreNever())
        {
            synchronized (this)
            {
                if (ItemLinkState.STATE_AVAILABLE == _itemLinkState)
                {
                    if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
                        SibTr.debug(this, tc, "removing STORE_NEVER item as a result of discard");

                    ListStatistics stats = getParentStatistics();
                    synchronized (stats)
                    {
                        stats.decrementAvailable();
                        stats.decrementTotal(_inMemoryItemSize);
                    }

                    _itemLinkState = ItemLinkState.STATE_NOT_STORED;
                    unlink = true;
                }
            }
        }

        if (unlink)
        {
            getMessageStoreImpl().unregister(this);
            unlink();
        }
    }
1176787
void close() {
    acquireExclusiveLock();
    try {

      if (buffer != null) {
        if (dirty)
          buffer.force();

        if (sunClass != null) {
          // USE SUN JVM SPECIAL METHOD TO FREE RESOURCES
          try {
            final Method m = sunClass.getMethod("cleaner");
            final Object cleaner = m.invoke(buffer);
            cleaner.getClass().getMethod("clean").invoke(cleaner);
          } catch (Exception e) {
            OLogManager.instance().error(this, "Error on calling Sun's MMap buffer clean", e);
          }
        }

        buffer = null;
      }
      counter = 0;
      file = null;

    } finally {
      releaseExclusiveLock();
    }
  }
856748
def unlink(self, func):
        '''
        

        '''
        if func in self._syn_links:
            self._syn_links.remove(func)
404762
def unlink(link):
    
    if islink(link) and platform.system() == "Windows" and sys.version_info[:2] < (3, 5):
        # deleting junction points was added to os.unlink in 3.5
        # https://bugs.python.org/issue18314
        subprocess.check_call(["rmdir", link], shell=True)
    else:
        os.unlink(link)
199651
public void destroy()
  {
    TempBuffer ptr = _head;

    _head = null;
    _tail = null;

    TempBuffer.freeAll(ptr);
  }
510728
function () {
                this._removeOldStates();
                ariaUtilsEvent.removeListener(window, "unload", this._saveStateCB);
                this._storage.setItem(this._STORAGE_KEY, stateMemory);
                this._storage.$dispose();
                this._storage = null;
            }
673989
def free_memory(self):
        """"""
        self.main.free_memory()
        QTimer.singleShot(self.INITIAL_FREE_MEMORY_TIME_TRIGGER,
                          lambda: self.main.free_memory())
        QTimer.singleShot(self.SECONDARY_FREE_MEMORY_TIME_TRIGGER,
                          lambda: self.main.free_memory())
1083696
def unlink(self):
        
        links = self.registry.get(self.source)
        if self in links:
            links.pop(links.index(self))
49767
def unload(self):
        

        if self.loaded:
            self.loaded = False
            self._openalprpy_lib.dispose(self.alpr_pointer)
693612
def clear(self):
        
        with self._hlock:
            self.handlers.clear()
        with self._mlock:
            self.memoize.clear()
1290315
public function unlink() {
		if($this->isOpen()) {
			$this->close();
		}
		if($this->exists()) {
			if(unlink($this->filepath)) {
				$this->unlinked = true;
			}
		}
	}