}

    @Override
    public DefaultDeploymentDescriptor module(EarModule module, String type) {
        modules.add(module);
        moduleTypeMappings.put(module.getPath(), type);
        return this;
    }

    @Override
    public DefaultDeploymentDescriptor module(String path, String type) {
        return module(new DefaultEarModule(path), type);
    }

        }
        for (File dir : getPath()) {
            File candidate = new File(dir, exeName);
            if (candidate.isFile()) {
                return candidate;
            }
        }

        return null;
    }

    public List<File> findAllInPath(String name) {
        List<File> all = new LinkedList<File>();

        for (File dir : getPath()) {

        lock.lock();
        RequestOutcome outcome;
        try {
            outcome = new RequestOutcome(lock, httpExchange.getRequestMethod(), httpExchange.getRequestURI().getPath());
            outcomes.add(outcome);
        } finally {
            lock.unlock();
        }
        return outcome;
    }

    private void requestFailed(RequestOutcome outcome, Throwable t) {

                writeBuildIdentifierOf(projectComponentIdentifier, encoder);
                encoder.writeString(projectComponentIdentifier.getIdentityPath().getPath());
                break;
            }
            case OTHER_BUILD_PROJECT: {
                DefaultProjectComponentIdentifier projectComponentIdentifier = (DefaultProjectComponentIdentifier) value;

        public abstract static class Entry {

            private final String path;

            public Entry(String path) {
                this.path = path;
            }

            public String getPath() {
                return path;
            }

        }

        static class FileEntry extends Entry {

            private final String hash;

                                if (useScalaSdk) {
                                    declareScalaSdk(scalaCompilerLibraries.get(project.getPath()), xmlProvider.asNode());
                                } else {
                                    declareScalaFacet(scalaCompilerLibraries.get(project.getPath()), xmlProvider.asNode());
                                }
                            }
                        });

            } else if (location instanceof OffsetInFileLocation) {
                OffsetInFileLocation fileLocation = (OffsetInFileLocation) location;
                return new org.gradle.internal.build.event.types.DefaultOffsetInFileLocation(fileLocation.getPath(), fileLocation.getOffset(), fileLocation.getLength());

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            stopwordsService.getStopwordsFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadStopwordsFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

                form.dictId = dictId;
            });
        }).renderWith(data -> {
            protwordsService.getProtwordsFile(dictId).ifPresent(file -> {
                RenderDataUtil.register(data, "path", file.getPath());
            }).orElse(() -> {
                throwValidationError(messages -> messages.addErrorsFailedToDownloadProtwordsFile(GLOBAL), this::asDictIndexHtml);
            });
        });
    }

        }
    }

    @Override
    public boolean expecting(HttpExchange exchange) {
        if (notReceived.isEmpty()) {
            return false;
        }
        String path = exchange.getRequestURI().getPath().substring(1);
        ResourceHandlerWrapper handler = selectPending(notReceived, path);
        return handler != null;
    }

    @Override