How to use

push

method

in

org.hibernate.search.util.impl.common.Closer

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( IdentifierMapping::close, identifierMapping );
    closer.push( RoutingKeyProvider::close, routingKeyProvider );
    closer.push( PojoIndexingProcessor::close, processor );
    closer.push( PojoImplicitReindexingResolver::close, reindexingResolver );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ContainerExtractorHolder::close, extractorHolder );
    closer.pushAll( PojoIndexingProcessor::close, nestedNodes );
  }
}

@Override
public void close() {
  if ( !closed ) {
    // Make sure to avoid infinite recursion when one of the delegates calls this.close()
    closed = true;
    try ( Closer<RuntimeException> closer = new Closer<>() ) {
      closer.push( PojoMappingDelegate::close, delegate );
      closer.pushAll( CloseDelegate::close, closeDelegates );
    }
  }
}

@Override
protected void doClose() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ElasticsearchBatchingSharedWorkOrchestrator::awaitCompletionBeforeClose, this );
    closer.push( ExecutorService::shutdownNow, executor );
    //It's possible that a task was successfully scheduled but had no chance to run,
    //so we need to release waiting threads:
    closer.push( Phaser::forceTermination, phaser );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ContainerExtractorHolder::close, extractorHolder );
    closer.pushAll( PojoImplicitReindexingResolverNode::close, nestedNodes );
  }
}

void closeOnFailure() {
  if ( closed ) {
    return;
  }
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( PojoIndexingProcessorTypeNodeBuilder::closeOnFailure, processorBuilder );
    closer.push( PojoIdentityMappingCollectorImpl::closeOnFailure, identityMappingCollector );
    closer.push( PojoIndexingProcessor::close, preBuiltIndexingProcessor );
    closed = true;
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ContainerExtractorHolder::close, extractorHolder );
    closer.pushAll( PojoImplicitReindexingResolverNode::close, nestedNodes );
  }
}

@Override
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ContainerExtractorHolder::close, extractorHolder );
    closer.push( PojoImplicitReindexingResolverValueNodeBuilderDelegate::closeOnFailure, valueBuilderDelegate );
  }
}

void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( AbstractPojoImplicitReindexingResolverNodeBuilder::closeOnFailure, typeNodeBuilder );
    closer.pushAll(
        AbstractPojoImplicitReindexingResolverNodeBuilder::closeOnFailure, castedTypeNodeBuilders.values()
    );
  }
}

@Override
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( ContainerExtractorHolder::close, extractorHolder );
    closer.push( PojoImplicitReindexingResolverValueNodeBuilderDelegate::closeOnFailure, valueBuilderDelegate );
  }
}

@Override
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( PojoImplicitReindexingResolverMarkingNodeBuilder::closeOnFailure, markingNodeBuilder );
    closer.pushAll(
        AbstractPojoImplicitReindexingResolverNodeBuilder::closeOnFailure,
        propertyNodeBuilders.values()
    );
  }
}

@Override
public void close() {
  try ( Closer<IOException> closer = new Closer<>() ) {
    closer.push( ElasticsearchWorkOrchestrator::close, queryOrchestrator );
    closer.push( ElasticsearchWorkOrchestratorProvider::close, orchestratorProvider );
    // Close the index writer after the orchestrators and work processor, when we're sure all works have been performed
    closer.push( ElasticsearchClientImplementor::close, client );
  }
  catch (IOException | RuntimeException e) {
    throw log.failedToShutdownBackend( e, eventContext );
  }
}

@Override
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( PojoImplicitReindexingResolverValueNodeBuilderDelegate::closeOnFailure, valueWithoutExtractorsBuilderDelegate );
    closer.pushAll(
        AbstractPojoImplicitReindexingResolverNodeBuilder::closeOnFailure, containerElementNodeBuilders.values()
    );
  }
}

@Override
public void close() {
  try ( Closer<IOException> closer = new Closer<>() ) {
    closer.push( ElasticsearchWorkOrchestrator::close, queryOrchestrator );
    closer.push( ElasticsearchWorkOrchestratorProvider::close, orchestratorProvider );
    // Close the index writer after the orchestrators and work processor, when we're sure all works have been performed
    closer.push( ElasticsearchClientImplementor::close, client );
  }
  catch (IOException | RuntimeException e) {
    throw log.failedToShutdownBackend( e, eventContext );
  }
}

@Override
public void close() {
  try ( Closer<IOException> closer = new Closer<>() ) {
    closer.push( LuceneIndexWorkOrchestrator::close, serialOrchestrator );
    closer.push( LuceneIndexWorkOrchestrator::close, parallelOrchestrator );
    // Close the index writer after the orchestrators, when we're sure all works have been performed
    closer.push( IndexWriter::close, indexWriter );
    closer.push( LuceneIndexModel::close, model );
  }
  catch (IOException | RuntimeException e) {
    throw log.failedToShutdownBackend( e, getBackendAndIndexEventContext() );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( LuceneQueryWorkOrchestrator::close, queryOrchestrator );
  }
}

@Override
public void close() {
  try ( Closer<IOException> closer = new Closer<>() ) {
    closer.push( ElasticsearchWorkOrchestrator::close, serialOrchestrator );
    closer.push( ElasticsearchWorkOrchestrator::close, parallelOrchestrator );
    closer.push( strategy -> strategy.onStop( administrationClient ), managementStrategy );
  }
  catch (IOException e) {
    throw log.failedToShutdownIndexManager( hibernateSearchIndexName, e, indexingBackendContext.getEventContext() );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( holder -> holder.get().close(), bridgeHolder );
    closer.push( BeanHolder::close, bridgeHolder );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( holder -> holder.get().close(), bridgeHolder );
    closer.push( BeanHolder::close, bridgeHolder );
  }
}

private synchronized void cleanup(HibernateSearchContextService context) {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.push( c -> c.getIntegration().close(), context );
    // TODO JMX
    // closer.push( JMXHook::unRegisterIfRegistered, jmx );
  }
}