List up all {@link BuildWrapperDescriptor}s that are applicable for the given project.

@return
The signature doesn't use {@link BuildWrapperDescriptor} to maintain compatibility
with {@link BuildWrapper} implementations before 1.150.
979137
public static List<Descriptor<BuildWrapper>> getFor(AbstractProject<?, ?> project) {
        List<Descriptor<BuildWrapper>> result = new ArrayList<>();
        Descriptor pd = Jenkins.getInstance().getDescriptor((Class)project.getClass());

        for (Descriptor<BuildWrapper> w : BuildWrapper.all()) {
            if (pd instanceof AbstractProjectDescriptor && !((AbstractProjectDescriptor)pd).isApplicable(w))
                continue;
            if (w instanceof BuildWrapperDescriptor) {
                BuildWrapperDescriptor bwd = (BuildWrapperDescriptor) w;
                if(bwd.isApplicable(project))
                    result.add(bwd);
            } else {
                // old BuildWrapper that doesn't implement BuildWrapperDescriptor
                result.add(w);
            }
        }
        return result;
    }
575944
public static DescriptorExtensionList<SCMCheckoutStrategy,SCMCheckoutStrategyDescriptor> all() {
        return Jenkins.getInstance().<SCMCheckoutStrategy,SCMCheckoutStrategyDescriptor>getDescriptorList(SCMCheckoutStrategy.class);
    }
1165494
public String getBuildDescription() {
        StringBuilder sb = new StringBuilder();
        for (String name : startParameter.getExcludedTaskNames()) {
            sb.append("-x ");
            sb.append(name);
            sb.append(" ");
        }
        for (String name : startParameter.getTaskNames()) {
            sb.append(name);
            sb.append(" ");
        }
        String tasks = sb.toString();
        if (tasks.length() == 0) {
            tasks = "(no tasks specified)";
        }
        return "Profiled build: " + tasks;
    }
942665
public List<FacesConfigApplicationType<WebFacesConfigDescriptor>> getAllApplication()
   {
      List<FacesConfigApplicationType<WebFacesConfigDescriptor>> list = new ArrayList<FacesConfigApplicationType<WebFacesConfigDescriptor>>();
      List<Node> nodeList = model.get("application");
      for(Node node: nodeList)
      {
         FacesConfigApplicationType<WebFacesConfigDescriptor>  type = new FacesConfigApplicationTypeImpl<WebFacesConfigDescriptor>(this, "application", model, node);
         list.add(type);
      }
      return list;
   }
189389
public String [] getParamTypeDescriptors() {
        return methodType().parameterList().stream()
                .map(BSHType::getTypeDescriptor).toArray(String[]::new);
    }
155401
public java.util.List<String> getCompatibleRuntimes() {
        if (compatibleRuntimes == null) {
            compatibleRuntimes = new com.amazonaws.internal.SdkInternalList<String>();
        }
        return compatibleRuntimes;
    }
1142587
public java.util.List<? extends com.google.api.Distribution.ExemplarOrBuilder> 
      getExemplarsOrBuilderList() {
    return exemplars_;
  }
539464
public java.util.List<? extends com.google.iam.v1.BindingOrBuilder> 
      getBindingsOrBuilderList() {
    return bindings_;
  }
1321674
public static DescriptorExtensionList<RepositoryBrowser<?>,Descriptor<RepositoryBrowser<?>>> all() {
        return (DescriptorExtensionList) Jenkins.getInstance().getDescriptorList(RepositoryBrowser.class);
    }
855074
public List<TargetWrapperDescriptor> listAllTargets() {

		this.logger.finer( "Listing all the available targets." );
		WebResource path = this.resource.path( UrlConstants.TARGETS );
		List<TargetWrapperDescriptor> result =
				this.wsClient.createBuilder( path )
				.accept( MediaType.APPLICATION_JSON )
				.type( MediaType.APPLICATION_JSON )
				.get( new GenericType<List<TargetWrapperDescriptor>> () {});

		if( result != null )
			this.logger.finer( result.size() + " target descriptors were found." );
		else
			this.logger.finer( "No target descriptor was found." );

		return result != null ? result : new ArrayList<TargetWrapperDescriptor>( 0 );
	}
619964
public static List<ClassRef> findBuildableReferences(ClassRef ref) {
        List<ClassRef>  result = new ArrayList<>();
        TypeDef def = new TypeDefBuilder(ref.getDefinition())
                .accept(new TypedVisitor<ClassRefBuilder>() {
                    @Override
                    public void visit(ClassRefBuilder builder) {
                        ClassRef candidate = builder.build();
                        if (isBuildable(candidate)) {
                            result.add(candidate);
                        }
                    }
                })
                .build();
        return result;
    }
415125
public static Description buildDescriptionWith(Consumer<DescriptionBuilder> builder) {
        DescriptionBuilder builder1 = builder();
        builder.accept(builder1);
        return builder1.build();
    }
1087147
public java.util.List<? extends com.google.rpc.Help.LinkOrBuilder> 
      getLinksOrBuilderList() {
    return links_;
  }
598276
@Deprecated
    private static ListAttributeDefinition wrapAsList(final AttributeDefinition def) {
        final ListAttributeDefinition list = new ListAttributeDefinition(new SimpleListAttributeDefinition.Builder(def.getName(), def)
                .setElementValidator(def.getValidator())) {


            @Override
            public ModelNode getNoTextDescription(boolean forOperation) {
                final ModelNode model = super.getNoTextDescription(forOperation);
                setValueType(model);
                return model;
            }

            @Override
            protected void addValueTypeDescription(final ModelNode node, final ResourceBundle bundle) {
                setValueType(node);
            }

            @Override
            public void marshallAsElement(final ModelNode resourceModel, final boolean marshalDefault, final XMLStreamWriter writer) throws XMLStreamException {
                throw new RuntimeException();
            }

            @Override
            protected void addAttributeValueTypeDescription(ModelNode node, ResourceDescriptionResolver resolver, Locale locale, ResourceBundle bundle) {
                setValueType(node);
            }

            @Override
            protected void addOperationParameterValueTypeDescription(ModelNode node, String operationName, ResourceDescriptionResolver resolver, Locale locale, ResourceBundle bundle) {
                setValueType(node);
            }

            private void setValueType(ModelNode node) {
                node.get(ModelDescriptionConstants.VALUE_TYPE).set(ModelType.STRING);
            }
        };
        return list;
    }
1370261
public String getDescriptor() {
            StringBuilder stringBuilder = new StringBuilder().append('(');
            for (TypeDescription parameterType : parameterTypes) {
                stringBuilder.append(parameterType.getDescriptor());
            }
            return stringBuilder.append(')').append(returnType.getDescriptor()).toString();
        }
38721
@TaskAction
    public void packageForSwarm() throws Exception {
        final Project project = getProject();
        final ThorntailExtension extension = getThorntailExtension();

        GradleArtifactResolvingHelper resolvingHelper = new GradleArtifactResolvingHelper(project);
        Properties propertiesFromExtension = extension.getProperties();
        Set<File> moduleDirs = extension.getModules();
        if (moduleDirs.isEmpty()) {
            Path resourcesOutputDir = project.getConvention()
                    .getPlugin(JavaPluginConvention.class)
                    .getSourceSets()
                    .findByName(SourceSet.MAIN_SOURCE_SET_NAME)
                    .getOutput()
                    .getResourcesDir()
                    .toPath()
                    .resolve(MODULE_DIR_NAME);
            if (Files.isDirectory(resourcesOutputDir)) {
                File moduleDir = resourcesOutputDir.toFile();

                moduleDirs.add(moduleDir);
            }
        }


        BuildTool tool = new BuildTool(resolvingHelper)
                .projectArtifact(this.jarTask.getGroup(), this.jarTask.getBaseName(), this.jarTask.getVersion(),
                                 getPackaging(), getProjectArtifactFile())
                .mainClass(getMainClassName())
                .bundleDependencies(extension.isBundleDependencies())
                .executable(extension.isIncludeExecutable())
                .executableScript(extension.getExecutableScript())
                .properties(propertiesFromExtension)
                .properties(getPropertiesFromFile())
                .properties(PropertiesUtil.filteredSystemProperties(propertiesFromExtension, false))
                .fractionDetectionMode(extension.getFractionDetectionMode())
                .hollow(extension.isHollow())
                .additionalModules(moduleDirs.stream()
                                           .filter(File::exists)
                                           .map(File::getAbsolutePath)
                                           .collect(Collectors.toList()))
                .logger(new SimpleLogger() {
                    @Override
                    public void debug(String msg) {
                        getLogger().debug(msg);
                    }

                    @Override
                    public void info(String msg) {
                        getLogger().info(msg);
                    }

                    @Override
                    public void error(String msg) {
                        getLogger().error(msg);
                    }

                    @Override
                    public void error(String msg, Throwable t) {
                        getLogger().error(msg, t);
                    }
                });

        tool.declaredDependencies(GradleToolingHelper.toDeclaredDependencies(extension.getDependencies()));
        tool.bundleDependencies(extension.isBundleDependencies());
        // Add the explicitly defined fractions from the configuration.
        extension.getDeclaredFractions().stream().map(DependencyDescriptor::toArtifactSpec).forEach(tool::fraction);
        // Build the Thorntail archive.
        tool.build(getOutputFile().getName(), getOutputDirectory());

        /* We expect a war task to be present before scanning for war files. */
        final java.util.Optional<Task> task = project.getTasks().stream().filter(t -> "war".equals(t.getName())).findAny();
        if (task.isPresent()) {
            /* Look for all the war archives present */
            final Set<File> warArchives = project.getConfigurations()
                    .stream()
                    .map(Configuration::getAllArtifacts)
                    .map(PublishArtifactSet::getFiles)
                    .map(FileCollection::getFiles)
                    .flatMap(Collection::stream)
                    .filter(f -> f.getName().endsWith(".war"))
                    .collect(Collectors.toSet());
            for (File warArchive : warArchives) {
                tool.repackageWar(warArchive);
            }
        }
    }
778096
public java.util.List<? extends com.google.javascript.jscomp.RequirementOrBuilder> 
      getRequirementOrBuilderList() {
    return requirement_;
  }