Returns true if the specified processor must be created to process XML.
11803
private boolean isProcessXMLNeeded(InjectionProcessorProvider<?, ?> provider)
    {
        final boolean isTraceOn = TraceComponent.isAnyTracingEnabled();
        if (isTraceOn && tc.isEntryEnabled())
            Tr.entry(tc, "isProcessXMLNeeded: " + provider);

        List<Class<? extends JNDIEnvironmentRef>> refClasses = provider.getJNDIEnvironmentRefClasses();
        if (refClasses == null)
        {
            if (isTraceOn && tc.isEntryEnabled())
                Tr.exit(tc, "isProcessXMLNeeded: true (unknown)");
            return true;
        }

        for (Class<? extends JNDIEnvironmentRef> refClass : refClasses)
        {
            List<? extends JNDIEnvironmentRef> refs = ivNameSpaceConfig.getJNDIEnvironmentRefs(refClass);
            if (refs != null && !refs.isEmpty())
            {
                if (isTraceOn && tc.isEntryEnabled())
                    Tr.exit(tc, "isProcessXMLNeeded: true (" + refClass.getName() + ")");
                return true;
            }
        }

        if (isTraceOn && tc.isEntryEnabled())
            Tr.exit(tc, "isProcessXMLNeeded: false");
        return false;
    }
13968
private ProcessingItem createPi(Processor processor, int parallelism) {
        ProcessingItem pi = this.componentFactory.createPi(processor, parallelism);
        this.topology.addProcessingItem(pi, parallelism);
        return pi;
    }
1167210
@Override
    public Set<IProcessor> getProcessors(String dialectPrefix) { // only once called when first access
        final Set<IProcessor> processors = createLastaProcessorsSet();
        processors.addAll(getAdditionalProcessors());
        return processors;
    }
1190348
def get_processor(self, entity_id, sp_config):
        
        processor_string = sp_config.get('processor', None)
        if processor_string:
            try:
                return import_string(processor_string)(entity_id)
            except Exception as e:
                logger.error("Failed to instantiate processor: {} - {}".format(processor_string, e), exc_info=True)
                raise
        return BaseProcessor(entity_id)
1336676
public ProcessesXmlParse createParse() {
    ProcessesXmlParse processesXmlParse = new ProcessesXmlParse(this);
    processesXmlParse.setSchemaResource(ReflectUtil.getResourceUrlAsString(PROCESS_APPLICATION_XSD));
    return processesXmlParse;
  }
271169
private Element addProcessors(Document document, Element root,
			Map<ReportBuilderImpl.ReportKey, Object> reportsData) {
		if (reportsData.containsKey(ReportKey.PROCESSORS)) {
			// Adds root tag "processors".
			Element processors = document.createElement("processors");
			root.appendChild(processors);

			// Adds all processors in child of "processors" tag.
			String[] tabProcessors = (String[]) reportsData
					.get(ReportKey.PROCESSORS);
			for (String processor : tabProcessors) {
				Element current = document.createElement("processor");
				current.appendChild(document.createTextNode(processor));
				processors.appendChild(current);
			}
			return processors;
		}
		return null;
	}
1156148
def can_run_pconf(self, pconf):
        """"""
        if not self.hint_cores >= pconf.num_cores >= self.min_cores: return False
        if not self.hw.can_use_omp_threads(self.omp_threads): return False
        if pconf.mem_per_proc > self.hw.mem_per_node: return False
        if self.allocation == "force_nodes" and pconf.num_cores % self.hw.cores_per_node != 0:
            return False

        return self.condition(pconf)
352261
protected Processor getProcessor() {
    if (isReference()) {
      return ((ProcessorDef) getCheckedRef(ProcessorDef.class, "ProcessorDef")).getProcessor();
    }
    //
    // if a processor has not been explicitly set
    // then may be set by an extended definition
    if (this.processor == null) {
      final ProcessorDef extendsDef = getExtends();
      if (extendsDef != null) {
        return extendsDef.getProcessor();
      }
    }
    return this.processor;
  }
662783
@Override
	public Processor newProcessor(Processor p) {
		AMRDefaultRuleProcessor oldProcessor = (AMRDefaultRuleProcessor) p;
		Builder builder = new Builder(oldProcessor);
		AMRDefaultRuleProcessor newProcessor = builder.build();
		newProcessor.resultStream = oldProcessor.resultStream;
		newProcessor.ruleStream = oldProcessor.ruleStream;
		return newProcessor;
	}
71040
boolean isAlreadyProcessed(
            final CtClass ctClass,
            final ClassProcessor processor) {
        final ClassFile classFile = ctClass.getClassFile();
        AnnotationsAttribute annotationAttribute = null;
        for (final Object attributeObject : classFile.getAttributes()) {
            if (attributeObject instanceof AnnotationsAttribute) {
                annotationAttribute = (AnnotationsAttribute) attributeObject;
                final Annotation annotation = annotationAttribute.getAnnotation(PROCESSED_ANNOTATION_CLASS);
                if (annotation != null) {
                    final MemberValue value = annotation.getMemberValue("value");
                    _log.debug("Existing processed annotation on: " + ctClass.getName() + " = " + value);
                    final ArrayMemberValue valueArray = (ArrayMemberValue) value;
                    for (final MemberValue processorValue : valueArray.getValue()) {
                        final StringMemberValue processorValueString = (StringMemberValue) processorValue;
                        if (processor.getClass().getName().equals(processorValueString.getValue())) {
                            return true;
                        }
                    }
                }
            }
        }
        _log.debug("No annotation attribute or processed annotation found on: " + ctClass.getName());
        return false;
    }
422486
private static boolean requiredByPlatformFeature(File baseDir, File testFile) {
        try {
            Map<String, ProvisioningFeatureDefinition> features = new Product(baseDir).getFeatureDefinitions();
            for (ProvisioningFeatureDefinition fd : features.values()) {
                if (fd.isKernel()) {
                    if (requiredByFile(fd, baseDir, testFile))
                        return true;
                }
            }
        } catch (Exception e) {
        }
        return false;
    }
816773
private void startupProcessor() {
        Processor processor = processorRef.get();
        if (processor == null) {
            processor = new Processor();
            if (processorRef.compareAndSet(null, processor)) {
                executor.execute(new NamePreservingRunnable(processor,
                        threadName));
            }
        }

        // Just stop the select() and start it again, so that the processor
        // can be activated immediately. 
        wakeup();
    }
1059000
boolean isValidToCreate(String src) {
    String srcs = normalizePath(src);
    byte[][] components = INodeDirectory.getPathComponents(srcs);
    readLock();
    try {
      if (srcs.startsWith("/") &&
          !srcs.endsWith("/") &&
          rootDir.getNode(components) == null) {
        return true;
      } else {
        return false;
      }
    } finally {
      readUnlock();
    }
  }
117752
protected static function validateProcessor($processor)
    {
        if (!is_subclass_of($processor, AbstractProcessor::class)) {
            throw new InvalidArgumentException('Processor must be an instanceof ' . AbstractProcessor::class);
        }
        return is_string($processor) ? new $processor() : $processor;
    }
726579
private static boolean requiredByOtherFeature(ContentBasedLocalBundleRepository br, Map<String, ProvisioningFeatureDefinition> features, File b) {
        for (ProvisioningFeatureDefinition fd : features.values()) {
            if (requiredByJar(br, fd, b))
                return true;
        }
        return false;
    }
214855
def get_processor(self,
                      name,
                      mappings=None,
                      processor_type=None,
                      **kwargs):
        
        try:
            return self.processors[name]
        except KeyError:
            return  self.make_processor(name,
                                        mappings,
                                        processor_type,
                                        **kwargs)
759905
def create(self, xml):
        
        res = yield queue.executeInThread(self.connection.createXML, xml, 0)
        return self.DomainClass(self, res)