Close the given store.

@param store The store.
177187
public void closeStore(Store store) {
        close(store);
        StoreKey key = keysByStore.remove(store);
        storesByKey.remove(key);
    }
244821
@Override
	public void close(boolean compact, boolean cleanup) {
		logger.debug("close");
		super.close(compact, cleanup);
	    if (this.getDatabaseServer() == null) {
	    	return;
	    }
	    
	    try {
	        // shutdown
	    	((HsqldbDatabaseServer)this.getDatabaseServer()).shutdown(compact);
        } catch (Exception e) {
            logger.error(e.getMessage(), e);
        }
	}
803923
@Override
    public synchronized void close() throws BackendException {
        if (!isOpen) return;
        this.isOpen = false;
        if (readExecutor!=null) readExecutor.shutdown();
        if (sendThread!=null) sendThread.close(CLOSE_DOWN_WAIT);
        if (readExecutor!=null) {
            try {
                readExecutor.awaitTermination(1,TimeUnit.SECONDS);
            } catch (InterruptedException e) {
                log.error("Could not terminate reader thread pool for KCVSLog "+name+" due to interruption");
            }
            if (!readExecutor.isTerminated()) {
                readExecutor.shutdownNow();
                log.error("Reader thread pool for KCVSLog "+name+" did not shut down in time - could not clean up or set read markers");
            } else {
                for (MessagePuller puller : msgPullers) {
                    puller.close();
                }
            }
        }
        writeSetting(manager.senderId, MESSAGE_COUNTER_COLUMN, numMsgCounter.get());
        store.close();
        manager.closedLog(this);
    }
242195
func (store *MemoryStore) Close() {
	store.Lock()
	defer store.Unlock()
	chkcond(store.opened)
	store.opened = false
	DEBUG.Println(STR, "memorystore closed")
}
275761
@Override
    public void close() throws IOException {
        debug(String.format("close jar provider loader for: %s", pluginJar));
        synchronized (this) {
            closed = true;
        }
        if (null != cachedJar) {
            cachedJar.close();
            classCache.clear();
            cachedJar = null;
        }
    }
534959
public void clear() {
		for (Object component : store.values()) {
			try {
				Event.of(Passivated.class).on(component).fire();
			} catch (Exception e) {}
		}
		
		for (Object component : store.values()) {
			try {
				Event.of(Destroyed.class).on(component).fire();
			} catch (Exception e) {}
		}
		
		store.clear();
	}
1238761
func (store *FileStore) Close() {
	store.Lock()
	defer store.Unlock()
	store.opened = false
	WARN.Println(STR, "store is not open")
}
50062
public synchronized void close()
	{
		if (s != null) {
			super.close();
			try {
				s.close();
			}
			catch (final IOException e) {}
			s = null;
		}
	}
1128795
public void deleteStore() throws BlockStoreException {
        maybeConnect();
        try {
            Statement s = conn.get().createStatement();
            for(String sql : getDropTablesSQL()) {
                s.execute(sql);
            }
            s.close();
        } catch (SQLException ex) {
            throw new RuntimeException(ex);
        }
    }
420669
@Override
	public final void close() throws JMSException
    {
    	synchronized (closeLock)
		{
	    	if (closed)
	    		return;
	    	closed = true;
		}
    	
    	ActivityWatchdog.getInstance().unregister(this);
    	
    	synchronized (storeLock)
		{
	        if (volatileStore != null)
	        {
	            volatileStore.close();
	            
	            // Delete message store if the queue was temporary
	            if (queueDef.isTemporary())
	                volatileStore.delete();
	        }
	        if (persistentStore != null)
	        {
	            persistentStore.close();
	            
	            // Delete message store if the queue was temporary
	            if (queueDef.isTemporary())
	                persistentStore.delete();
	        }
		}
    	
    	// Create a snapshot to avoid concurrent modification
    	List<LocalMessageConsumer> consumers;
    	consumersLock.readLock().lock();
    	try
    	{
    		if (localConsumers.isEmpty())
    			return;
    		
    		consumers = new ArrayList<>(localConsumers);
    	}
    	finally
    	{
    		consumersLock.readLock().unlock();
    	}	
    		
    	// Close all consumers
    	for (int n=0;n<consumers.size();n++)
        {
	        LocalMessageConsumer consumer = consumers.get(n);
	        try
	        {
	            consumer.close();
	        }
	        catch (JMSException e)
	        {
	            ErrorTools.log(e, log);
	        }
        }
    }
967132
@Override
    public void close() {
        if (this.closed.compareAndSet(false, true)) {
            Futures.await(Services.stopAsync(this, this.executor));
            this.storage.close();
            log.info("Closed.");
        }
    }
274153
public void close() {
        try {
            state = "CLOSING";
            if( connection != null ) {
                logger.warn("Connection not committed, rolling back.");
                rollback();
            }
            if( !events.empty() ) {
                state = "CLOSING EVENTS";
                do {
                    Execution exec = (Execution)events.pop();
                
                    try {
                        Stack<Execution> stack;
                        
                        exec.close();
                        stack = eventCache.get(exec.getClass().getName());
                        if( stack != null ) {
                            stack.push(exec);
                        }
                    }
                    catch( Throwable t ) {
                        logger.error(t.getMessage(), t);
                    }
                } while( !events.empty() );
            }
            state = "CLOSED";
        }
        finally {
            if (tracking) {
                transactions.remove(new Integer(transactionId));
            }
            events.clear();
            statements.clear();
            stackTrace = null;
        }
    }
1327820
public void delete() {
    // Delete the log.
    storage.deleteLog(name);

    // Delete the snapshot store.
    storage.deleteSnapshotStore(name);

    // Delete the metadata store.
    storage.deleteMetaStore(name);
  }
1040066
def _Close(self):
    """"""
    if self._database_object:
      self._database_object.Close()

    self._blob = None
    self._current_offset = 0
    self._size = 0
    self._table_name = None
533266
@Override
	public synchronized void close() {
		Set<IXADataRecorder> recoveredXADataRecorders = this.getRecoveredXADataRecorders();
		for (IXADataRecorder dataRecorder : recoveredXADataRecorders) {
			dataRecorder.disqualify();			
		}
	}
807936
public void close() {
        if (transactionalBranch != null) {
            XATransactionalBranch<C> branch= this.transactionalBranch;
            this.release();
            branch.getManagedConnection().close();
        }

    }
750086
@Override
    public void registerStore(IStore store) {
        _store = store;
        _store.setStoreCallback(_storeCallback);
        if (store instanceof ISessionObserver) {
            this.registerSessionObserver((ISessionObserver) store);
        }
        if (store instanceof ISessionStateObserver) {
            this.registerSessionStateObserver((ISessionStateObserver) store);
        }
    }