import org.gradle.internal.time.Timer;

import java.io.IOException;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;

import static org.gradle.internal.UncheckedException.throwAsUncheckedException;

/**
 * Serializes the transient parts of the resolved configuration results.
 */
public class TransientConfigurationResultsBuilder {

            // Wait for a short while to check for unexpected requests
            try {
                Thread.sleep(500);
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
            doReleaseAction(handler, yetToBeReceived);
        });
    }

    abstract void doReleaseAction(BlockingHttpServer.BlockingHandler handler, int yetToBeReceived);

    }

    public String getOutputAsString() {
        try {
            return buffer.toString(outputEncoding);
        } catch (UnsupportedEncodingException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

                    setState(State.Unblocking, State.Failed);
                    throw UncheckedException.throwAsUncheckedException(e);
                } finally {
                    setBlockingThread(null);
                }
            } catch (InterruptedException e) {
                throw UncheckedException.throwAsUncheckedException(e);
            }
        }

        private ThreadHandle getBlockingThread() {

        try {
            return new URI(repositoryUrl + "/" + archiveName + "-" + version.getVersion() + "-" + archiveClassifier + ".zip");
        } catch (URISyntaxException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

        try {
            return object.getClass().getMethod("toString").getDeclaringClass() == Object.class;
        } catch (java.lang.NoSuchMethodException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    /**
     * Resolves the return type of a method in a given class.
     *

                public T call() {
                    return createResourceLock(key, producer);
                }
            });
        } catch (ExecutionException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private T createResourceLock(final K key, final AbstractResourceLockRegistry.ResourceLockProducer<K, T> producer) {
        return producer.create(key, coordinationService, owner);
    }

            DEPENDENCY_CONFIG_FIELD.setAccessible(true);
        } catch (NoSuchFieldException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private final ImmutableModuleIdentifierFactory moduleIdentifierFactory;

    public IvyModuleDescriptorConverter(ImmutableModuleIdentifierFactory moduleIdentifierFactory) {

    private void cleanupOutputDir() {
        try {
            FileUtils.deleteDirectory(getOutputsDir());
            getOutputsDir().mkdir();
        } catch (IOException e) {
            throw UncheckedException.throwAsUncheckedException(e);
        }
    }

    private List<ExecutionOutput> getOutputFiles() {
        List<ExecutionOutput> outputFiles = new ArrayList<>();
        for (File executionDir : getOutputsDir().listFiles()) {

                        try {
                            DefaultSynchronizer.this.wait();
                        } catch (InterruptedException e) {
                            throw UncheckedException.throwAsUncheckedException(e);
                        }
                    }
                    owner = currentThread;
                }
            }
        });
        return null;
    }