How to use

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

constructor

public void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( PojoIndexedTypeManager::close, byExactClass.values() );
  }
}

public void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( PojoImplicitReindexingResolverBuilder::closeOnFailure, builderByType.values() );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( BeanHolder::close, chainElementBeanHolders );
  }
}

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

@Override
public void closeOnFailure() {
  if ( !closed ) {
    closed = true;
    try ( Closer<RuntimeException> closer = new Closer<>() ) {
      closer.pushAll( PojoIndexedTypeManagerBuilder::closeOnFailure, indexedTypeManagerBuilders.values() );
    }
  }
}

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

  @Override
  public void close() {
    try ( Closer<RuntimeException> closer = new Closer<>() ) {
      closer.pushAll( BeanHolder::close, delegates );
    }
  }
}

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( PojoImplicitReindexingResolverValueNodeBuilderDelegate::closeOnFailure, valueWithoutExtractorsBuilderDelegate );
    closer.pushAll(
        AbstractPojoImplicitReindexingResolverNodeBuilder::closeOnFailure, containerElementNodeBuilders.values()
    );
  }
}

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

@Override
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( ContainerExtractorHolder::close, extractorHolder );
    closer.pushAll(
        PojoIndexingProcessorValueNodeBuilderDelegate::closeOnFailure,
        valueNodeProcessorCollectionBuilder
    );
  }
}

@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 );
    }
  }
}

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 );
  }
}

@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( holder -> holder.get().close(), bridgeHolder );
    closer.push( BeanHolder::close, bridgeHolder );
  }
}

@Override
public void close() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( PojoIndexedTypeManager::close, indexedTypeManagers.getAll() );
    closer.pushAll( PojoContainedTypeManager::close, containedTypeManagers.getAll() );
  }
}

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

@Override
public void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( boundBridge -> boundBridge.getBridgeHolder().get().close(), boundBridges );
    closer.pushAll( boundBridge -> boundBridge.getBridgeHolder().close(), boundBridges );
    closer.pushAll( PojoIndexingProcessorPropertyNodeBuilder::closeOnFailure, propertyNodeBuilders.values() );
  }
}

@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
void closeOnFailure() {
  try ( Closer<RuntimeException> closer = new Closer<>() ) {
    closer.pushAll( boundBridge -> boundBridge.getBridgeHolder().get().close(), boundBridges );
    closer.pushAll( boundBridge -> boundBridge.getBridgeHolder().close(), boundBridges );
    closer.pushAll( PojoIndexingProcessorTypeNodeBuilder::closeOnFailure, typeNodeBuilders );
  }
}