Deletes a the byte array used to store the exception information.  Subclasses may override
to provide custom implementations.
185724
protected void deleteExceptionByteArrayRef(DeadLetterJobEntity jobEntity) {
        ByteArrayRef exceptionByteArrayRef = jobEntity.getExceptionByteArrayRef();
        if (exceptionByteArrayRef != null) {
            exceptionByteArrayRef.delete();
        }
    }
1331757
public void deleteParts() {
        if (!_parsed)
            return;

        Collection<Part> parts;
        try {
            parts = getParts();
        } catch (IOException e) {
            throw new RuntimeException(e);
        }

        MultiException err = null;
        for (Part p : parts) {
            try {
                ((MultiPart) p).cleanUp();
            } catch (Exception e) {
                if (err == null)
                    err = new MultiException();
                err.add(e);
            }
        }
        _parts.clear();

        if (err != null)
            err.ifExceptionThrowRuntime();
    }
1345599
private boolean remove(HashtableEntry entry)
                    throws IOException,
                    EOFException,
                    FileManagerException,
                    ClassNotFoundException,
                    HashtableOnDiskException {
        if (entry == null) {
            throw (new HashtableOnDiskException("remove: Internal error, null entry."));
        }

        removes++;
        //
        // First unchain from hashtable
        //
        if (entry.location == getHtindex(entry.index, entry.tableid)) { // first in chain
            writeHashIndex(entry.index, entry.next, entry.tableid);
        } else { // not first in chain
            updatePointer(entry.previous, entry.next);
        }

        //
        // Now delete data
        //
        header.decrementObjectCount();
        filemgr.deallocate(entry.location); // deallocate from disk
        filemgr.flush();

        return true;
    }
372386
public void doRemove() throws DBException
    {
        super.doRemove();
        if (m_arrayCache != null)
            if (m_iLogicalIndex != -1)
                m_arrayCache.set(m_iLogicalIndex, null);    // Show the current record as deleted.
    }
955934
public void deleteCurrent(SITransaction simpTran)
  throws SISessionUnavailableException, SISessionDroppedException,
         SIIncorrectCallException,
         SIErrorException
  {
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.entry(CoreSPILockedMessageEnumeration.tc, "deleteCurrent", this);
      
    checkValidState("deleteCurrent");
    
    _localConsumerPoint.checkNotClosed();
    
    if (!_messageAvailable)
    {
      if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
        SibTr.exit(CoreSPILockedMessageEnumeration.tc, "deleteCurrent", "Invalid current Message");
        
      throw new SIIncorrectCallException(
        nls.getFormattedMessage("INVALID_MESSAGE_ERROR_CWSIP0191", 
          new Object[] { _localConsumerPoint.getConsumerManager().getDestination().getName(),
            _localConsumerPoint.getConsumerManager().getMessageProcessor().getMessagingEngineName() }, 
          null));
    }
    
    _singleMessage = null;
    _messageAvailable = false;
    
    if (TraceComponent.isAnyTracingEnabled() && CoreSPILockedMessageEnumeration.tc.isEntryEnabled())
      SibTr.exit(CoreSPILockedMessageEnumeration.tc, "deleteCurrent");
  }
1176705
public void destroy(Exception e) {
        if (this.appCallback != null) {
            this.appCallback.destroy(e);
            this.appCallback = null;
        }
    }
1045736
public byte[] remove() throws Exception
    {
        byte[] bytes = internalElement(true, null);
        if ( bytes == null )
        {
            throw new NoSuchElementException();
        }
        return bytes;
    }
1202783
synchronized void clear() throws IOException
   {
      if (out != null)
      {
         out.close();
         out = null;
      }
      try
      {
         if (dir.fileExists(REDO_LOG))
         {
            dir.deleteFile(REDO_LOG);
         }
      }
      catch (IOException e)
      {
         log.error(e.getLocalizedMessage(), e);
         throw e;
      }
      entryCount = 0;
   }
684461
public void remove() throws IOException
   {
      if ((fileBuffer != null) && PrivilegedFileHelper.exists(fileBuffer))
      {
         if (!PrivilegedFileHelper.delete(fileBuffer))
         {
            throw new IOException("Cannot remove file " + PrivilegedFileHelper.getAbsolutePath(fileBuffer)
               + " Close all streams.");
         }
      }
   }
1292594
@Override
  public void removeFailure(K key, StoreAccessException e) {
    try {
      loaderWriter.delete(key);
    } catch(Exception e1) {
      throw ExceptionFactory.newCacheWritingException(e1, e);
    } finally {
      cleanup(key, e);
    }
  }
324175
public void delete() {
    Buffer buffer = this.buffer instanceof SlicedBuffer ? ((SlicedBuffer) this.buffer).root() : this.buffer;
    if (buffer instanceof FileBuffer) {
      ((FileBuffer) buffer).delete();
    } else if (buffer instanceof MappedBuffer) {
      ((MappedBuffer) buffer).delete();
    }

    offsetIndex.delete();
  }
531782
static void clear(byte[][] blocks, int off, int len) {
    // this is significantly faster than looping or Arrays.fill (which loops), particularly when
    // the length of the slice to be cleared is <= to ARRAY_LEN (in that case, it's faster by a
    // factor of 2)
    int remaining = len;
    while (remaining > ARRAY_LEN) {
      System.arraycopy(NULL_ARRAY, 0, blocks, off, ARRAY_LEN);
      off += ARRAY_LEN;
      remaining -= ARRAY_LEN;
    }

    System.arraycopy(NULL_ARRAY, 0, blocks, off, remaining);
  }
566547
public boolean deleteObject (ObjectInfo info)
    {
        int oidx = -1;
        for (int ii = 0; ii < _objects.length; ii++) {
            if (_objects[ii].info.equals(info)) {
                oidx = ii;
                break;
            }
        }
        if (oidx == -1) {
            return false;
        }
        _objects = ArrayUtil.splice(_objects, oidx, 1);

        // clear out our neighbors array so that the subsequent update
        // causes us to recompute our coverage
        Arrays.fill(_neighbors, null);
        return true;
    }
282225
public void destroy() throws Exception {
        for (Properties properties : propertiesArray) {
            if (properties instanceof ReloadableProperties) {
                logger.debug("remove property listener: " + properties.toString());
                ((ReloadableProperties) properties).removeReloadablePropertiesListener(this);
            }
        }
    }
525660
public void delete() throws IOException, PlivoRestException {
    validate();
    Response<ResponseBody> response = obtainCall().execute();

    handleResponse(response);
  }
917262
public void delete() throws IOException {

        try {
            load(false);
            ensureLock();
            m_cms.deleteResource(m_cms.getSitePath(m_resource), CmsResource.DELETE_PRESERVE_SIBLINGS);
            if (!m_resource.getState().isNew()) {
                try {
                    m_cms.unlockResource(m_cms.getSitePath(m_resource));
                } catch (CmsException e) {
                    LOG.warn(e.getLocalizedMessage(), e);
                }
            }
        } catch (CmsException e) {
            throw CmsJlanDiskInterface.convertCmsException(e);
        }
    }
215417
public void destroy(Exception e) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            if (e == null) {
                Tr.entry(tc, "destroy(null)");
            } else {
                Tr.entry(tc, "destroy(Exc) " + e.getMessage());
            }
        }

        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled() && getVirtualConnection().getConnectionDescriptor() != null) {
            Tr.debug(tc, "Destroying the connection: " + getVirtualConnection().getConnectionDescriptor());
        }

        if (this.socketIOChannel != null) {
            this.socketIOChannel.close();
            this.tcpChannel.decrementConnectionCount();
        }

        // clearing references will help free up memory in case someone
        // above us doesn't release the reference to this connlink
        this.socketIOChannel = null;
        this.reader = null;
        this.writer = null;

        super.destroy(e);
        this.tcpChannel.releaseConnectionLink(this, this.inUseIndex);

        if (TraceComponent.isAnyTracingEnabled() && tc.isEntryEnabled()) {
            Tr.exit(tc, "destroy()");
        }
    }