Free the specified slot.
2552
public void freeSlot(WorkerSlot slot) {
        // remove the slot from the existing assignments
        for (SchedulerAssignmentImpl assignment : this.assignments.values()) {
            if (assignment.isSlotOccupied(slot)) {
                assignment.unassignBySlot(slot);
            }
        }
    }
862014
def free_memory(cls, exclude=None):
        """"""

        annotations_in_memory = Annotation.__ANNOTATIONS_IN_MEMORY__

        exclude = () if exclude is None else exclude

        for annotation_cls in list(annotations_in_memory.keys()):

            if issubclass(annotation_cls, exclude):
                continue

            if issubclass(annotation_cls, cls):
                del annotations_in_memory[annotation_cls]
99814
public void free() {
    if (consumer != null) {
      if (array != null) {
        consumer.freeArray(array);
      }
      array = null;
    }
  }
547020
public void unassignBySlot(WorkerSlot slot) {
        List<ExecutorDetails> executors = new ArrayList<>();
        for (ExecutorDetails executor : this.executorToSlot.keySet()) {
            WorkerSlot ws = this.executorToSlot.get(executor);
            if (ws.equals(slot)) {
                executors.add(executor);
            }
        }

        // remove
        for (ExecutorDetails executor : executors) {
            this.executorToSlot.remove(executor);
        }
    }
468086
public void freeIfDone()
    {
        boolean bValidAppFound = false;
        for (int i = 0; i < this.getApplicationCount(); i++)
        {
            Application application = (Application)this.m_vApplication.get(i);
            if (!DBConstants.FALSE.equalsIgnoreCase(this.getProperty(DBParams.FREEIFDONE)))
                if (application == this.getDefaultApplication())
                	if (this.isApplicationDone(application))
                		continue;
            if (application instanceof MessageApp)
                continue;
            bValidAppFound = true;
        }
        if (!bValidAppFound)
            this.free();
    }
806169
def free(self):
        
        # Free the memory
        self._machine_controller.sdram_free(self._start_address,
                                            self._x, self._y)

        # Mark as freed
        self._freed = True
720052
public void free()
    {
        m_converter = null;
        for (int i = this.getComponentCount() - 1; i >= 0; i--)
        {
            JComponent component = (JComponent)this.getComponent(i);
            if (component instanceof Freeable)
                ((Freeable)component).free();
        }
    }
35383
def _set_slots_to_null(self, cls):
        
        if hasattr(cls, "__slots__"):
            for s in cls.__slots__:
                self.__setattr__(s, Null)
        for b in cls.__bases__:
            self._set_slots_to_null(b)
829466
public function free(): void
    {
        if ($this->type == self::TYPE_MYSQL_RESULT) {
            $this->object->free();
        } elseif ($this->type == self::TYPE_PGSQL_RESULT) {
            pg_free_result($this->object);
        }

        $this->reset();
    }
547029
public void free()
    {
        if (m_PDatabase != null)
            m_PDatabase.removePTable(this);
        m_PDatabase = null;

        if (m_VKeyList != null)
        {
            for (int i = m_VKeyList.size() - 1 ; i >= 0 ;i--) {
                PKeyArea vKeyArea = (PKeyArea)m_VKeyList.elementAt(i);
                vKeyArea.free();
            } 
            m_VKeyList.removeAllElements();
        }
        m_VKeyList = null;
        
        if (m_setPTableOwners != null)
        {
            for (ThinPhysicalTableOwner owner : m_setPTableOwners)
            {
                this.removePTableOwner(owner, false);
            }
        }
    }
608567
def _free(self, ptr):
        
        raise NotImplementedError("%s not implemented for %s" % (self._free.__func__.__name__,
                                                                 self.__class__.__name__))
621801
private void removeMount(SlotReference slot) {
        mediaDetails.remove(slot);
        if (mediaMounts.remove(slot)) {
            deliverMountUpdate(slot, false);
        }
    }
955538
public void free()
    {
        this.setPDatabaseParent(null); // Remove from database
        
        Object[] keys = m_htTableList.keySet().toArray();
        for (int i = 0; i < keys.length; i++)
        { 
            Object key = keys[i];
            PTable pTable = m_htTableList.get(key);
            if (pTable != null)
                pTable.free();      // This can be dangerous if the PhysicalTables still have references to the PTables
        } 
        m_htTableList.clear();
        m_htTableList = null;
        this.close();
    }
1069121
public void free(IPooledObject<V> borrowedObject, boolean reusable) {
		if (borrowedObject == null) return;

		if (borrowed.remove(borrowedObject))
		{
			((PoolableObject<V>)borrowedObject).releaseOwner();
			if (reusable)
				available.addFirst((PoolableObject<V>)borrowedObject);
		}
	}
995783
public function free()
	{
		if ( ! is_null($this->nestedSetNode)) {
			$this->nestedSetNode->free($this);
			$this->nestedSetNode = null;
		}
	}
230236
public void free()
    {
        try   {
            if (m_tableRemote != null)
                m_tableRemote.freeRemoteSession();
        } catch (RemoteException ex) {
            ex.printStackTrace();
        }
        m_tableRemote = null;
        super.free();
    }
885445
private function free()
    {
        $this->readable = false;

        if ($this->deferred !== null) {
            $deferred = $this->deferred;
            $this->deferred = null;
            $deferred->resolve();
        }

        Loop::cancel($this->watcher);

        if ($this->immediateWatcher !== null) {
            Loop::cancel($this->immediateWatcher);
        }
    }