Processa uma linha detalhe do arquivo.
@param string $linha Linha detalhe do arquivo processado
@return string Retorna um vetor contendo os dados dos campos da linha detalhe.
543108
protected function processarDetalhe($linha)
    {
        $detail = parent::processarDetalhe($linha);
        $detail
            ->setConvenio($linha->substr(32, 7)->trim())
            ->setControle($linha->substr(38, 25)->trim())
            ->setNossoNumero($linha->substr(64, 17)->trim())
            ->setTipoCobranca($linha->substr(81, 1)->trim())
            ->setTipoCobrancaCmd72($linha->substr(82, 1)->trim())
            ->setDiasCalculo($linha->substr(83, 4)->trim())
            ->setNatureza($linha->substr(87, 2)->trim())
            ->setPrefixoTitulo($linha->substr(89, 3)->trim())
            ->setVariacaoCarteira($linha->substr(92, 3)->trim())
            ->setContaCaucao($linha->substr(95, 1)->trim())
        ;
        return $detail;
    }
579758
public function action($action = null)
    {
        if (!is_null($action)) {
            $this->action = $action;
            return $this;
        } else {
            return $this->action ?: '';
        }
    }
395060
public function getAttribute($key)
    {
        // Verificar alias para _id
        $key = ($key == 'id') ? '_id' : $key;

        // Verificar se foi implemetado um relacionamento
        $value = $this->getRelationValue($key);
        if (! is_null($value)) {
            return $value;
        }

        // Verificar se o campo existe fisicamente ou foi implementado um mutator
        if (array_key_exists($key, $this->attributes) || $this->hasGetMutator($key)) {
            return $this->getAttributeValue($key);
        }

        return null;
    }
978734
public function getPluralForm($root) {
		$pluralForm = $root;

		if (!is_string($root)) {
			throw new \InvalidArgumentException('The pluralizer expects a string.');
		}

		if (!in_array(strtolower($root), $this->uncountable)) {
			// This check must be run before `checkIrregularForm` call
			if (!$this->isAmbiguousPlural($root)) {
				if (null !== $replacement = $this->checkIrregularForm($root, $this->irregular)) {
					$pluralForm = $replacement;
				} elseif (null !== $replacement = $this->checkIrregularSuffix($root, $this->plural)) {
					$pluralForm = $replacement;
				} elseif (!$this->isPlural($root)) {
					// fallback to naive pluralization
					$pluralForm = $root . 's';
				}
			}
		}

		return $pluralForm;
	}
1290311
public function getEncoded()
    {
        $text = array();
        foreach ($this->listSegmento() as $segmento) {
            $text[] = $segmento->getEncoded();
        }

        return implode(Arquivo::QUEBRA_LINHA, $text);
    }
1185977
public function processar()
    {
        $retorno = new Retorno();
        $lote = null;

        $lines = file($this->processor->getNomeArquivo(), FILE_IGNORE_NEW_LINES);
        foreach ($lines as $lineNumber => $lineContent) {
            $string = new Stringy(rtrim($lineContent, "\r\n"));
            $composable = $this->processor->processarLinha($lineNumber, $string);

            if ($this->processor->needToCreateLote()) {
                $lote = $this->createLote($retorno);
            }

            $this->processor->processCnab($retorno, $composable, $lote);

            $event = new OnDetailRegisterEvent($this->processor, $lineNumber, $composable);
            $this->dispatcher->dispatch(RetornoEvents::ON_DETAIL_REGISTER, $event);
        }

        return $retorno;
    }
125122
public function toArray()
    {
        // Planilhas do Gnumeric e Xlsx
        // possuem linha e colunas nulas na exportação de array
        // por isso, são removidas aqui

        $list = [];
        $array = $this->getActiveSheet()->toArray();

        // Linhas
        foreach($array as $row_id => $rows) {

            $line = array_filter($rows, function($v){ return !is_null($v); });
            if (!empty($line)) {
                $list[] = $line;
            }
        }

        return $list;
    }
170240
public static function make($file)
    {
        if (!$file_content = Util::file2array($file)) {
            throw new \Exception("Arquivo: não existe");
        }

        if (!Util::isHeaderRetorno($file_content[0])) {
            throw new \Exception("Arquivo: $file, não é um arquivo de retorno");
        }

        $instancia = self::getBancoClass($file_content);
        return $instancia->processar();
    }
550578
private static function processAsset($string, $name, $return, $filenamePath)
    {
        $filePath = $filenamePath;
        if (file_exists($filenamePath)) {
            list($base, $htmlBase, $filePath) = AssetsParser::calculateAssetPath($string, $name, $return, $filenamePath);
            //Creamos el directorio si no existe
            GeneratorHelper::createDir($base . $htmlBase);
            //Si se ha modificado
            if (!file_exists($base . $filePath) || filemtime($base . $filePath) < filemtime($filenamePath)) {
                if ($htmlBase === 'css') {
                    self::processCssLines($filenamePath);
                }
                self::putResourceContent($name, $filenamePath, $base, $filePath);
            }
        }

        return $filePath;
    }
956201
public static function atualizarLinhaDigitavel($linha, Carbon $vencto, $valor)
    {
        $inicio = substr($linha, 0, 32);

        $vencto = str_pad(self::fatorVencimento($vencto), 4, '0', STR_PAD_LEFT); // Novo fator de vencimento
        $valor = str_pad(self::fatorValor($valor), 10, '0', STR_PAD_LEFT); // Valor atualizado

        // Montar nova barra para calcular o novo dígito
        $barra = substr($linha, 0, 4)
            //. substr($linha, 32,  1)
            . $vencto . $valor
            . substr($linha, 4, 5)
            . substr($linha, 10, 10)
            . substr($linha, 21, 10);

        $digito = self::modulo11($barra);

        return sprintf('%s%s%s%s', $inicio, $digito, $vencto, $valor);
    }
848213
public function process(): string
    {
        while ($this->string->valid()) {
            $this->handleTxt();
            $this->handleComment();
            $this->handleMultiline();
            $this->append();
        }

        $this->removeWhitespace();

        return $this->normalisedString;
    }
1039383
protected static function pem2Der($pemData)
    {
        $begin = 'CERTIFICATE-----';
        $end = '-----END';
        //extrai o conteúdo do certificado entre as marcas BEGIN e END
        $pemData1 = substr($pemData, strpos($pemData, $begin) + strlen($begin));
        $pemData2 = substr($pemData1, 0, strpos($pemData1, $end));
        //converte o resultado para binário obtendo um certificado em formato DER
        $derData = base64_decode((string) $pemData2);

        return $derData;
    }
1128304
protected function processarHeaderArquivo($linha)
    {
        $header = $this->createHeader();
        //X = ALFANUMÉRICO 9 = NUMÉRICO V = VÍRGULA DECIMAL ASSUMIDA
        $header->setRegistro(substr($linha, 1, 1))
            ->setTipoOperacao(substr($linha, 2, 1))
            ->setIdTipoOperacao(substr($linha, 3, 7))
            ->setIdTipoServico(substr($linha, 10, 2))
            ->setTipoServico(substr($linha, 12, 15));

        $empresa = new Empresa();
        $empresa->setCod(substr($linha, 27, 20))
            ->setNome(substr($linha, 47, 30));

        $banco = new Banco();
        $banco
            ->setCod(substr($linha, 77, 3))
            ->setNome(substr($linha, 80, 15));


        $cedente = new Cedente();
        $cedente->setBanco($banco)
            ->setNome(substr($linha, 47, 30));

        $header->setEmpresa($empresa)
            ->setCedente($cedente)
            ->setDataGravacao($this->createDate(substr($linha, 95, 6)))
            ->setDensidadeGravacao(substr($linha, 101, 8))
            ->setNumAvisoCredito(substr($linha, 109, 5))
            ->setSequencialReg(substr($linha, 395, 6));

        return $header;
    }
267241
public function process_cdata($cdata) {
        global $CFG;
        if ($cdata === '$@NULL@$') {  // Some cases we know we can skip complete processing
            return null;
        } else if ($cdata === '') {
            return '';
        } else if (is_numeric($cdata)) {
            return $cdata;
        } else if (strlen($cdata) < 32) { // Impossible to have one link in 32cc
            return $cdata;                // (http://10.0.0.1/file.php/1/1.jpg, http://10.0.0.1/mod/url/view.php?id=)
        } else if (strpos($cdata, '$@FILEPHP@$') === false) { // No $@FILEPHP@$, nothing to convert
            return $cdata;
        }

        if ($CFG->slasharguments) {
            $slash = '/';
            $forcedownload = '?forcedownload=1';
        } else {
            $slash = '%2F';
            $forcedownload = '&amp;forcedownload=1';
        }

        // We have to remove trailing slashes, otherwise file URLs will be restored with an extra slash.
        $basefileurl = rtrim(moodle_url::make_legacyfile_url($this->courseid, null)->out(true), $slash);
        // Decode file.php calls
        $search = array ("$@FILEPHP@$");
        $replace = array($basefileurl);
        $result = str_replace($search, $replace, $cdata);

        // Now $@SLASH@$ and $@FORCEDOWNLOAD@$ MDL-18799
        $search = array('$@SLASH@$', '$@FORCEDOWNLOAD@$');
        $replace = array($slash, $forcedownload);

        return str_replace($search, $replace, $result);
    }
399460
protected function processLinkUrl($url)
    {
        $_html  = !empty($url[0]) ? $url[0] : '';
        $_url   = $_html;
        $_title = $_html;

        // --------------------------------------------------------------------------

        //  Only process if there's a URL to process
        if ($_html && $_url) {
            $_html = $this->processLinkGenerate($_html, $_url, $_title, false);
        }

        return $_html;
    }
22742
public function process()
    {
        if ($this->isDerivedAttribute($this->attribute)) {
            return $this->createAgeVerification($this->attribute);
        }
        return null;
    }
1255238
protected function processarHeaderArquivo($linha)
    {
        $header = $this->createHeader();
        //X = ALFANUMÉRICO 9 = NUMÉRICO V = VÍRGULA DECIMAL ASSUMIDA
        $header->setRegistro($linha->substr(1, 1)->trim());
        $header->setTipoOperacao($linha->substr(2, 1)->trim());
        $header->setIdTipoOperacao($linha->substr(3, 7)->trim());
        $header->setIdTipoServico($linha->substr(10, 2)->trim());
        $header->setTipoServico($linha->substr(12, 8)->trim());
        $header->addComplemento($linha->substr(20, 7)->trim());

        $bancoArray = array();
        if (!preg_match('#^([\d]{3})(.+)#', $linha->substr(77, 18)->trim(), $bancoArray)) {
            throw new InvalidArgumentException('Banco invalido');
        }

        $banco = new Banco();
        $banco
            ->setCod($bancoArray[1])
            ->setNome($bancoArray[2])
            ->setAgencia($linha->substr(27, 4)->trim())
            ->setDvAgencia($linha->substr(31, 1)->trim())
            ->setConta($linha->substr(32, 8)->trim())
            ->setDvConta($linha->substr(40, 1)->trim());


        $cedente = new Cedente();
        $cedente->setBanco($banco)
            ->setNome($linha->substr(47, 30)->trim());

        $header->setCedente($cedente);
        $header->setDataGravacao($this->createDate($linha->substr(95, 6)->trim()));
        $header->setSequencialReg($linha->substr(395, 6)->trim());

        return $header;
    }