Obtains the appropriate processor (compiler, linker)

@return processor
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;
  }
750595
public function getIterator()
    {
        return new \ArrayIterator(array(
            'cod' => $this->getCod(),
            'cod_amount' => $this->getCodAmount(),
            'exw' => $this->getExw(),
            'rod' => $this->getRod(),
            'pod' => $this->getPod(),
            'exc' => $this->getExc(),
            'ident' => $this->getIdent(),
            'daw' => $this->getDaw(),
            'ps' => $this->getPs(),
            'pr' => $this->getPr(),
            's10' => $this->getS10(),
            's12' => $this->getS12(),
            'sat' => $this->getSat(),
            'ow' => $this->getOw(),
            'srs' => $this->getSrs()
        ));
    }
74882
public function getIterator()
    {
        $iter = parent::getIterator();

        // sorting support
        if ($this->sortby) {
            $desc = ($this->sortby_db[0] == '-');
            $order = ltrim($this->sortby_db, '-');
            $this->applySorting($iter, $order, $desc);
        }

        return $iter;
    }
1284106
function() {
        var processors = this._processors;

        _.each(processors, function(processor, name) {
            if (_.isString(processor)) {
                processors[name] = meta(processor);
            }
        });

        return processors;
    }
187874
private function _get_Win32_Processor()
    {
        if ($this->_Win32_Processor === null) $this->_Win32_Processor = CommonFunctions::getWMI($this->_wmi, 'Win32_Processor', array('LoadPercentage', 'AddressWidth', 'Name', 'L2CacheSize', 'L3CacheSize', 'CurrentClockSpeed', 'ExtClock', 'NumberOfCores', 'NumberOfLogicalProcessors', 'MaxClockSpeed'));
        return $this->_Win32_Processor;
    }
1055866
public static function all()
	{
		foreach (glob(__DIR__ . DIRECTORY_SEPARATOR . 'Processor' . DIRECTORY_SEPARATOR . '*.php') as $path)
		{
			$type = strtolower(basename($path, '.php'));

			if (!isset(self::$instances[$type]))
			{
				$class = __NAMESPACE__ . '\\Processor\\' . ucfirst($type);

				if (!class_exists($class))
				{
					include_once $path;
				}

				self::$instances[$type] = new $class;
			}
		}

		return self::$instances;
	}
1287093
public function getIterator(): \Iterator
    {
        if ($this->generator instanceof ArrayyRewindableGenerator) {
            return $this->generator;
        }

        $iterator = $this->getIteratorClass();

        if ($iterator === ArrayyIterator::class) {
            return new $iterator($this->getArray(), 0, static::class, false);
        }

        return new $iterator($this->getArray());
    }
1311218
public function getPreprocessor(): MiddlewareInterface
    {
        if (is_null($this->preProcessor)) {
            if (method_exists($this, 'resolve')) {
                $this->setPreprocessor($this->resolve(Middleware::class));
            } else {
                $this->setPreprocessor(new Middleware());
            }
        }

        return $this->preProcessor;
    }
343675
function processor() {
    var destination = unified()
    var length = attachers.length
    var index = -1

    while (++index < length) {
      destination.use.apply(null, attachers[index])
    }

    destination.data(extend(true, {}, namespace))

    return destination
  }
512784
public function compile()
    {
        if (null !== $this->compiled) {
            return $this->compiled;
        }

        $class = $this->getOption('compiler_class');

        return $this->compiled = $class::compile($this);
    }
224272
public final ProcessorDependencyGraph getProcessorGraph() {
        if (this.processorGraph == null) {
            synchronized (this) {
                if (this.processorGraph == null) {
                    final Map<String, Class<?>> attcls = new HashMap<>();
                    for (Map.Entry<String, Attribute> attribute: this.attributes.entrySet()) {
                        attcls.put(attribute.getKey(), attribute.getValue().getValueType());
                    }
                    this.processorGraph = this.processorGraphFactory.build(this.processors, attcls);
                }
            }
        }
        return this.processorGraph;
    }
562099
protected function _getIterator()
    {
        $data = &$this->_referDataArrayReference();
        foreach ($data as $k => $v) {
            (!array_key_exists($k, $this->__mapedPropObjects))
                ?: $k = $this->__mapedPropObjects[$k];

            yield $k => $v;
        }
    }
66287
public function build(ProcessorInterface $processor = null): PipelineInterface
    {
        if ($processor == null) {
            $processor = new InterruptibleProcessor(
                function (Command $command) {
                    return !$command->hasReturn();
                }
            );
        }
        return parent::build($processor);
    }
251746
public function getLtiLinkResource()
    {
        if (is_null($this->ltiLink)) {
            $service = $this->getServiceLocator()->get(LinkService::SERVICE_ID);
            $consumer = $this->getLaunchData()->getLtiConsumer();
            $linkId = $service->getLinkId($consumer->getUri(), $this->getLaunchData()->getResourceLinkID());
            $this->ltiLink = new core_kernel_classes_Resource($linkId);
        }
        return $this->ltiLink;
    }
810518
def get_processors(self):
        ""
        procs_x,procs_y = listify(self.train.x._processor),listify(self.train.y._processor)
        xp = ifnone(self.train.x.processor, [p(ds=self.train.x) for p in procs_x])
        yp = ifnone(self.train.y.processor, [p(ds=self.train.y) for p in procs_y])
        return xp,yp
281172
public function getIterator()
    {

        if ($this->iteratorCache) {
            return $this->iteratorCache;
        }

        $this->parseInputOnce();

        $this->iteratorCache = $this->createTraversable($this->filters, $this->sorting(), $this->queryKeys());

        return $this->iteratorCache;
    }
888211
public function getCompiler()
    {
        if ($this->compiler == null) {
            $this->compiler = new \PytoTPL\Compiler($this, $this->config);
        }

        return $this->compiler;
    }