Gets all component builders that are expected to generate an
{@link AnalyzerResult}.

@return
508294
public Collection<ComponentBuilder> getResultProducingComponentBuilders() {
        final Collection<ComponentBuilder> componentBuilders = getComponentBuilders();

        return CollectionUtils.filter(componentBuilders, componentBuilder -> {
            final ComponentDescriptor<?> descriptor = componentBuilder.getDescriptor();
            return ReflectionUtils.is(descriptor.getComponentClass(), HasAnalyzerResult.class);
        });
    }
106041
public List<Analyzer> getAnalyzers(List<AnalysisPhase> phases) {
        final List<Analyzer> analyzers = new ArrayList<>();
        final Iterator<Analyzer> iterator = service.iterator();
        boolean experimentalEnabled = false;
        boolean retiredEnabled = false;
        try {
            experimentalEnabled = settings.getBoolean(Settings.KEYS.ANALYZER_EXPERIMENTAL_ENABLED, false);
            retiredEnabled = settings.getBoolean(Settings.KEYS.ANALYZER_RETIRED_ENABLED, false);
        } catch (InvalidSettingException ex) {
            LOGGER.error("invalid experimental or retired setting", ex);
        }
        while (iterator.hasNext()) {
            final Analyzer a = iterator.next();
            if (!phases.contains(a.getAnalysisPhase())) {
                continue;
            }
            if (!experimentalEnabled && a.getClass().isAnnotationPresent(Experimental.class)) {
                continue;
            }
            if (!retiredEnabled && a.getClass().isAnnotationPresent(Retired.class)) {
                continue;
            }
            LOGGER.debug("Loaded Analyzer {}", a.getName());
            analyzers.add(a);
        }
        return analyzers;
    }
649391
public static List<ChannelBuilder> builders(ClassLoader classLoader, ServiceDomain serviceDomain, KnowledgeComponentImplementationModel implementationModel) {
        List<ChannelBuilder> builders = new ArrayList<ChannelBuilder>();
        if (implementationModel != null) {
            ChannelsModel channelsModel = implementationModel.getChannels();
            if (channelsModel != null) {
                for (ChannelModel channelModel : channelsModel.getChannels()) {
                    if (channelModel != null) {
                        builders.add(new ChannelBuilder(classLoader, serviceDomain, channelModel));
                    }
                }
            }
        }
        return builders;
    }
863888
public java.util.List<? extends com.google.appengine.v1.LibraryOrBuilder> 
      getLibrariesOrBuilderList() {
    return libraries_;
  }
171892
public Set<ArtifactSpec> getTransientDependencies() {
        if (null == allTransient) {
            allTransient = getTransientDependencies(true, true);
        }
        return allTransient;
    }
689524
public Builder toBuilder() {
		return builder()
			.name(_name)
			.cmt(_comment)
			.desc(_description)
			.src(_source)
			.links(_links)
			.number(_number)
			.segments(_segments);
	}
929714
public @Nonnull
    Set<AbstractProject<?, ?>> getProjects() {
        Set<AbstractProject<?, ?>> r = new HashSet<>();
        for (AbstractProject<?, ?> p : Jenkins.get().allItems(AbstractProject.class))
            if (p.hasParticipant(this))
                r.add(p);
        return r;
    }
395634
public List<String> getAllColumnsToProject() {
    return ImmutableList.<String> builder().addAll(getKeyColumnsToProject()).addAll(getDeltaColumnsToProject()).build();
  }
535364
public List<FacesConfigComponentType<FacesConfigType<T>>> getAllComponent()
   {
      List<FacesConfigComponentType<FacesConfigType<T>>> list = new ArrayList<FacesConfigComponentType<FacesConfigType<T>>>();
      List<Node> nodeList = childNode.get("component");
      for(Node node: nodeList)
      {
         FacesConfigComponentType<FacesConfigType<T>>  type = new FacesConfigComponentTypeImpl<FacesConfigType<T>>(this, "component", childNode, node);
         list.add(type);
      }
      return list;
   }
780774
public static Builder builder() {
    return new AutoValue_BuildDto.Builder()
        .setArtifactName(Optional.empty())
        .setBuildDateTime(Optional.empty())
        .setVersion(Optional.empty());
  }
95769
public Components getComponents() {
        if (this.components == null) {
            // This is idempotent, so no need to synchronize ...

            // Calculate how many seconds, and don't lose any information ...
            BigDecimal bigSeconds = new BigDecimal(this.durationInNanos).divide(new BigDecimal(1000000000));
            // Calculate the minutes, and round to lose the seconds
            int minutes = bigSeconds.intValue() / 60;
            // Remove the minutes from the seconds, to just have the remainder of seconds
            double dMinutes = minutes;
            double seconds = bigSeconds.doubleValue() - dMinutes * 60;
            // Now compute the number of full hours, and change 'minutes' to hold the remainding minutes
            int hours = minutes / 60;
            minutes = minutes - (hours * 60);
            this.components = new Components(hours, minutes, seconds);
        }
        return this.components;
    }
867372
public List<Resource> buildResources() {
        List<Resource> resources = new ArrayList<Resource>();
        for (ResourceBuilder builder : _resourceBuilders) {
            Resource resource = builder.build();
            if (resource != null) {
                resources.add(resource);
            }
        }
        return resources;
    }
714297
public java.util.List<AnalysisSchemeStatus> getAnalysisSchemes() {
        if (analysisSchemes == null) {
            analysisSchemes = new com.amazonaws.internal.SdkInternalList<AnalysisSchemeStatus>();
        }
        return analysisSchemes;
    }
667960
public static DescriptorExtensionList<Builder,Descriptor<Builder>> all() {
        return Jenkins.getInstance().<Builder,Descriptor<Builder>>getDescriptorList(Builder.class);
    }
137678
public final ImmutableList<ObjectType> getImplementedInterfaces() {
    FunctionType superCtor = isConstructor() ? getSuperClassConstructor() : null;
    if (superCtor == null) {
      return implementedInterfaces;
    }
    ImmutableList.Builder<ObjectType> builder = ImmutableList.builder();
    builder.addAll(implementedInterfaces);
    while (superCtor != null) {
      builder.addAll(superCtor.implementedInterfaces);
      superCtor = superCtor.getSuperClassConstructor();
    }
    return builder.build();
  }
1165170
public final List<AbstractProject> getBuildTriggerUpstreamProjects() {
        ArrayList<AbstractProject> result = new ArrayList<AbstractProject>();
        for (AbstractProject<?,?> ap : getUpstreamProjects()) {
            BuildTrigger buildTrigger = ap.getPublishersList().get(BuildTrigger.class);
            if (buildTrigger != null)
                if (buildTrigger.getChildJobs(ap).contains(this))
                    result.add(ap);
        }
        return result;
    }
960319
public MethodInfo[] getConstructors() {
        int size = mMethods.size();
        List<MethodInfo> ctorsOnly = new ArrayList<MethodInfo>(size);

        for (int i=0; i<size; i++) {
            MethodInfo method = mMethods.get(i);
            if ("<init>".equals(method.getName())) {
                ctorsOnly.add(method);
            }
        }

        MethodInfo[] ctorsArray = new MethodInfo[ctorsOnly.size()];
        return ctorsOnly.toArray(ctorsArray);
    }