Delete the object from GPU memory. 

        Note that the GPU object will also be deleted when this gloo
        object is about to be deleted. However, sometimes you want to
        explicitly delete the GPU object explicitly.
5453
def delete(self):
        
        # We only allow the object from being deleted once, otherwise
        # we might be deleting another GPU object that got our gl-id
        # after our GPU object was deleted. Also note that e.g.
        # DataBufferView does not have the _glir attribute.
        if hasattr(self, '_glir'):
            # Send our final command into the queue
            self._glir.command('DELETE', self._id)
            # Tell master glir queue that this queue is no longer being used
            self._glir._deletable = True
            # Detach the queue
            del self._glir
611825
public boolean remove(O object) {
		Integer multiplicity = multiplicities.get(object);
		if (multiplicities.remove(object) == null) {
			return false;
		}
		decMultiplicityCount(multiplicity);
		return true;
	}
1193444
def clear(*objects_to_clear):
    
    if not hasattr(_thread_local_data, 'current_space'):
        return

    space = current_space()
    for obj in objects_to_clear:
        space.clear(obj)
1262376
def cleanup(self):
        ""
        if self.m_glVertBuffer != 0:
            glDeleteBuffers(1, (self.m_glIndexBuffer,))
            glDeleteVertexArrays( 1, (self.m_glVertArray,) )
            glDeleteBuffers(1, (self.m_glVertBuffer,))
            self.m_glIndexBuffer = 0
            self.m_glVertArray = 0
            self.m_glVertBuffer = 0
360694
def delete_objects(objects, request_options = {})
      check_array(objects)
      batch(build_batch('deleteObject', objects.map { |objectID| { :objectID => objectID } }, false), request_options)
    end
998795
public void remove (Object object) {
		if (!idToObject.containsValue(object, true)) return;
		int objectID = idToObject.findKey(object, true, -1);
		idToObject.remove(objectID);
		objectToID.remove(object, 0);
		if (TRACE) trace("kryonet", "Object " + objectID + " removed from ObjectSpace: " + object);
	}
184345
def delete_object(connection, container: str, object_meta_data: dict) -> None:
    
    connection.delete_object(container, object_meta_data['name'])
1297819
def delete(self, redis):
        '''  '''
        if self.index:
            redis.hdel(self.key(), getattr(self.obj, self.name))
304139
def delete_object(no, generation = 0)
            case no
            when Reference
                target = no
            when ::Integer
                target = Reference.new(no, generation)
            else
                raise TypeError, "Invalid parameter type : #{no.class}"
            end

            @revisions.each do |rev|
                rev.body.delete(target)
            end
        end
477905
def _delete_objects_not_in_list(self, cont, object_prefix=""):
        
        objnames = set(cont.get_object_names(prefix=object_prefix,
                full_listing=True))
        localnames = set(self._local_files)
        to_delete = list(objnames.difference(localnames))
        self._sync_summary["deleted"] += len(to_delete)
        # We don't need to wait around for this to complete. Store the thread
        # reference in case it is needed at some point.
        self._thread = self.bulk_delete(cont, to_delete, async_=True)
732098
def delete(self, name):
        """"""
        obj = self._get_object(name)
        if obj:
            return self.driver.delete_object(obj)
49767
def unload(self):
        

        if self.loaded:
            self.loaded = False
            self._openalprpy_lib.dispose(self.alpr_pointer)
242475
def delete_object(self, bucket, object_name):
        
        details = self._details(
            method=b"DELETE",
            url_context=self._url_context(bucket=bucket, object_name=object_name),
        )
        d = self._submit(self._query_factory(details))
        return d
1013351
void dispose()
  {
    if( _pp == null )
    {
      return;
    }

    EditorUtilities.invokeInDispatchThread( () -> {
      if( _bShowInStudioGlassPane )
      {
        LabGlassPane.getInstance().removeModalComponent( _pp );
      }
      else
      {
        _pw.dispose();
      }
      _pp = null;
      _pw = null;
    } );
  }
285415
public void delete(Vertex vtx) {
        if (vtx.prev == null) {
            head = vtx.next;
        } else {
            vtx.prev.next = vtx.next;
        }
        if (vtx.next == null) {
            tail = vtx.prev;
        } else {
            vtx.next.prev = vtx.prev;
        }
    }
999531
def delete_objects!(objects, request_options = {})
      res = delete_objects(objects, request_options)
      wait_task(res['taskID'], WAIT_TASK_DEFAULT_TIME_BEFORE_RETRY, request_options)
      res
    end
927480
def del_object_from_parent(self):
        
        if self.parent:
            self.parent.objects.pop(self.ref)