Called from the manager after a close. Removes the manager from the known managers.
972077
void removeManager(CacheManager cm) {
    synchronized (getLockObject()) {
      Map<String, CacheManager> _name2managers = loader2name2manager.get(cm.getClassLoader());
      _name2managers = new HashMap<String, CacheManager>(_name2managers);
      Object _removed = _name2managers.remove(cm.getName());
      Map<ClassLoader, Map<String, CacheManager>> _copy = new WeakHashMap<ClassLoader, Map<String, CacheManager>>(loader2name2manager);
      _copy.put(cm.getClassLoader(), _name2managers);
      loader2name2manager = _copy;
      if (cm.isDefaultManager()) {
        Map<ClassLoader, String> _defaultNameCopy = new WeakHashMap<ClassLoader, String>(loader2defaultName);
        _defaultNameCopy.remove(cm.getClassLoader());
        loader2defaultName = _defaultNameCopy;
      }
    }
  }
891249
def close(self):
        
        self._handle.remove()
        self._node_monitor_event_handle.remove()
        self._allocation_table.close()
1334299
def close(options={})
      PostMessage(handle, WM_SYSCOMMAND, SC_CLOSE, 0)
      wait_for_close(options) if (options[:wait_for_close] == true)
    end
1227254
def close(self):
        

        if self._recv_thread:
            self._recv_thread.kill()
            self._recv_thread = None

        if self._send_thread:
            self._send_thread.kill()
            self._send_thread = None

        if self._sock:
            self._sock.close()
            self._sock = None

        # Make sure to notify the manager we're closed
        super(TCPTendril, self).close()
1301143
def delete(self, del_objects=False):
        
        return self.manager.delete(self, del_objects=del_objects)
936204
public void removeAllAppenders() {
        ListIterator<Appender> ite = appenderList.listIterator();
        while (ite.hasNext()) {
            Appender appender = ite.next();
            if (appender != null && appender.isLogOpen()) {
                try {
                    appender.close();
                } catch (IOException e) {
                    Log.e(TAG, "Failed to close appender. " + e);
                }
            }
        }
        appenderList.clear();
    }
393283
void close() {
        if (this.project != null) {
            Util.logger().log(Level.FINE, "Closing Protege project {0}",
                    this.projectIdentifier);

            for (Iterator<ProjectListener> itr =
                         this.projectListeners.iterator(); itr.hasNext(); ) {
                this.project.removeProjectListener(itr.next());
                itr.remove();
            }
            try {
                this.project.dispose();
                Util.logger().fine("Done closing connection.");
            } catch (IllegalStateException e) {
                /*
                 * Protege registers a shutdown hook that is removed when
                 * dispose() is called on a project. However, we might call this
                 * method during an already started shutdown process. See
                 * documentation for java.lang.Runtime.removeShutdownHook. This
                 * exception should be harmless, unless there are other reasons
                 * dispose() could throw this exception?
                 */
                Util.logger().fine("Done closing connection.");
            } finally {
                this.project = null;
            }

        }
    }
574181
protected function resetAvailableManagers()
    {
        $this->managerStatus[self::FLAG_AVAILABLE] = $this->managerList;
        $this->managerStatus[self::FLAG_UNAVAILABLE] = array();
    }
1037822
public void clearJob() {
    EncodedImage oldEncodedImage;
    synchronized (this) {
      oldEncodedImage = mEncodedImage;
      mEncodedImage = null;
      mStatus = 0;
    }
    EncodedImage.closeSafely(oldEncodedImage);
  }
587595
def shutdown!
      unless @stopping
        Chore.logger.info "Manager shutting down started"
        @stopping = true
        Chore.run_hooks_for(:before_shutdown)
        @fetcher.stop!
        @worker_strategy.stop!
        Chore.logger.info "Manager shutting down completed"
      end
    end
195845
def close(self):
        
        if self.bOwnership and self.value not in (None, INVALID_HANDLE_VALUE):
            if Handle.__bLeakDetection:     # XXX DEBUG
                print("CLOSE HANDLE (%d) %r" % (self.value, self))
            try:
                self._close()
            finally:
                self._value = None
867723
public void destroy() {
        try {
            ctx.close();
        }
        catch (javax.naming.NamingException e) {
            LOG.warn("Error when closing", e);
        }
    }
683654
private void close(ManagedConnection mc)
   {
      log.debugf("Closing managed connection for recovery (%s)", mc);

      if (mc != null)
      {
         try
         {
            mc.cleanup();
         }
         catch (ResourceException ire)
         {
            log.debugf("Error during recovery cleanup", ire);
         }
      }

      if (mc != null)
      {
         try
         {
            mc.destroy();
         }
         catch (ResourceException ire)
         {
            log.debugf("Error during recovery destroy", ire);
         }
      }

      // The managed connection for recovery is now gone
      recoverMC = null;
   }
31043
def cleanup_logger(self):
        
        self.log_handler.close()
        self.log.removeHandler(self.log_handler)
1124465
private static void closeDB(PersistenceManager pm) {
        if (pm.currentTransaction().isActive()) {
            pm.currentTransaction().rollback();
        }
        pm.close();
        pm.getPersistenceManagerFactory().close();
    }
798101
def close(self):
        """"""

        # remove callbacks
        DatastoreLegacy.datastores[self.domain].remove(self)

        # delete data after the last instance is gone
        if self.release_storage and \
           not DatastoreLegacy.datastores[self.domain]:
            del DatastoreLegacy.store[self.domain]

        del self
678637
def close(self):
        
        self.save()
        self.manager.remove_temp()
        self.cfb.close()
        self.is_open = False
        self.f.close()