Processa uma linha_arquivo_retorno.
@param int $numLn Número_linha a ser processada
@param string $linha String contendo a linha a ser processada
@return array Retorna um vetor associativo contendo os valores_linha processada.
967235
public function processarLinha($numLn, Stringy $linha)
    {
        //é adicionado um espaço vazio no início_linha para que
        //possamos trabalhar com índices iniciando_1, no lugar_zero,
        //e assim, ter os valores_posição_campos exatamente
        //como no manual CNAB240
        $linha = $linha->insert(" ", 0);
        $tipoLn = $linha->substr(8, 1)->trim();

        $this->needToCreateLote = false;
        if ((string)$tipoLn == CNAB240Processor::HEADER_ARQUIVO) {
            $vlinha = $this->processarHeaderArquivo($linha);
        } else if ((string)$tipoLn == CNAB240Processor::HEADER_LOTE) {
            $this->needToCreateLote = true;
            $vlinha = $this->processarHeaderLote($linha);
        } else if ((string)$tipoLn == CNAB240Processor::DETALHE) {
            $vlinha = $this->processarDetalhe($linha);
        } else if ((string)$tipoLn == CNAB240Processor::TRAILER_LOTE) {
            $vlinha = $this->processarTrailerLote($linha);
        } else if ((string)$tipoLn == CNAB240Processor::TRAILER_ARQUIVO) {
            $vlinha = $this->processarTrailerArquivo($linha);
        }

        return $vlinha;
    }
525302
public function processar()
    {
        if ($this->isProcessado()) {
            return $this;
        }

        if (method_exists($this, 'init')) {
            call_user_func([$this, 'init']);
        }

        foreach ($this->file as $linha) {
            $recordType = $this->rem(8, 8, $linha);

            if ($recordType == '0') {
                $this->processarHeader($linha);
            } elseif ($recordType == '1') {
                $this->processarHeaderLote($linha);
            } elseif ($recordType == '3') {
                if ($this->getSegmentType($linha) == 'T') {
                    $this->incrementDetalhe();
                }

                if ($this->processarDetalhe($linha) === false) {
                    unset($this->detalhe[$this->increment]);
                    $this->increment--;
                }
            } elseif ($recordType == '5') {
                $this->processarTrailerLote($linha);
            } elseif ($recordType == '9') {
                $this->processarTrailer($linha);
            }
        }

        if (method_exists($this, 'finalize')) {
            call_user_func([$this, 'finalize']);
        }

        return $this->setProcessado();
    }
705866
public static function at($string, $num)
    {
        $num = (int) $num;

        if (Utf8String::strlen($string) < $num) {
            return null;
        }

        return Utf8String::substr($string, $num, 1);
    }
992707
private function recursiveProcess(
        Parameter $param,
        \SimpleXMLElement $node
    ) {
        $result = [];
        $type = $param->getType();

        if ($type == 'object') {
            $result = $this->processObject($param, $node);
        } elseif ($type == 'array') {
            $result = $this->processArray($param, $node);
        } else {
            // We are probably handling a flat data node (i.e. string or
            // integer), so let's check if it's childless, which indicates a
            // node containing plain text.
            if ($node->children()->count() == 0) {
                // Retrieve text from node
                $result = (string) $node;
            }
        }

        // Filter out the value
        if (isset($result)) {
            $result = $param->filter($result);
        }

        return $result;
    }
232344
protected function processarDetalhe($linha)
    {
        $detail = $this->createDetail();

        $bancoEmissor = new Banco();
        $bancoEmissor
            ->setAgencia(substr($linha, 22, 1))
            ->setDvAgencia(substr($linha, 31, 1))
            ->setConta(substr($linha, 23, 8))
            ->setDvConta(substr($linha, 31, 1));

        $bancoRecebedor = new Banco();
        $bancoRecebedor
            ->setCod(substr($linha, 166, 3))
            ->setAgencia(substr($linha, 169, 4))
            ->setDvAgencia(substr($linha, 173, 1));

        $bancoEmpresa = new Banco();
        $bancoEmpresa->setCod(substr($linha, 21, 17));
        $empresa = new Empresa();
        $empresa
            ->setBanco($bancoEmpresa)
            ->setTipoInscricao(substr($linha, 2, 2))
            ->setNumInscricao(substr($linha, 4, 14))
            ->addReservado(substr($linha, 38, 25));

        $detail
            ->setBancoEmissor($bancoEmissor)
            ->setBancoRecebedor($bancoRecebedor)
            ->setRegistro(substr($linha, 1, 1))
            ->setNumOcorrencia(substr($linha, 117, 10))
            ->setDataVencimento(substr($linha, 147, 6))
            ->setValor($this->formataNumero(substr($linha, 153, 13)))
            ->setDespCobranca(substr($linha, 176, 2))
            ->setOutrasDespesas($this->formataNumero(substr($linha, 189, 13)))
            ->setJurosAtraso($this->formataNumero(substr($linha, 202, 13)))
            ->setTaxaIof($this->formataNumero(substr($linha, 215, 13)))
            ->setDescontoConcedido($this->formataNumero(substr($linha, 241, 13)))
            ->setValorRecebido($this->formataNumero(substr($linha, 254, 13)))
            ->setJurosMora($this->formataNumero(substr($linha, 267, 13)))
            ->setOutrosRecebimentos($this->formataNumero(substr($linha, 280, 13)))
            ->setValorAbatimento($this->formataNumero(substr($linha, 228, 13)))
            ->setValorLancamento($this->formataNumero(substr($linha, 306, 13)))
            ->setIndicativoDc(substr($linha, 319, 1))
            ->setIndicadorValor(substr($linha, 320, 1))
            ->setValorAjuste($this->formataNumero(substr($linha, 321, 12)))
            ->setSequencial(substr($linha, 395, 6))
            ->setMotivoCodOcorrencia(substr($linha, 319, 10))
            ->setNumCartorio(substr($linha, 369, 2))
            ->setNumCartorio(substr($linha, 369, 2))
            ->setNumCartorio(substr($linha, 369, 2))
        ;

        return $detail;
    }
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;
    }
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;
    }
789646
public function ne($num) {
        if (!$this->_isValid) {
            return $this;
        }

        if ($this->_unsafeVar == $num) {
            $this->_isValid = false;
        }
        return $this;
    }
804061
public function setNumberOfMandatoryArguments( $number = 0 )
	{
		if( !is_int( $number ) )														//  no Integer given
			throw new InvalidArgument( 'No integer given' );							//  throw Exception
		if( $number === $this->numberArguments )										//  this Number is already set
			return FALSE;																//  do nothing
		$this->numberArguments	= $number;												//  set new Argument Number
		return TRUE;																	//  indicate Success
	}
147810
public function getValue($params = [], $processCallbacks = true)
    {
        if (!$this->isInstanceOf($this->value, $this->entityClass) && !empty($this->value)) {
            $data = null;
            if ($this->isArray($this->value) || $this->isArrayObject($this->value)) {
                $data = $this->value;
                $this->value = isset($data['id']) ? $data['id'] : false;
            }

            $this->value = $this->loadEntity($this->value);

            if ($this->value) {
                $this->value->populate($data);
            } elseif ($data) {
                $this->value = new $this->entityClass;
                $this->value->populate($data);
            }
        }

        if (!$this->value && !$this->isNull($this->defaultValue)) {
            $this->value = $this->getDefaultValue();
        }

        return $this->processGetValue($this->value, $params, $processCallbacks);
    }
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;
    }
1159050
public function zSignXML($xmldoc, $root, $node, $objSSLPriKey)
    {
        $nsDSIG = 'http://www.w3.org/2000/09/xmldsig#';
        $nsCannonMethod = 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315';
        $nsSignatureMethod = 'http://www.w3.org/2000/09/xmldsig#rsa-sha1';
        $nsTransformMethod1 = 'http://www.w3.org/2000/09/xmldsig#enveloped-signature';
        $nsTransformMethod2 = 'http://www.w3.org/TR/2001/REC-xml-c14n-20010315';
        $nsDigestMethod = 'http://www.w3.org/2000/09/xmldsig#sha1';
        //pega o atributo id do node a ser assinado
        $idSigned = (trim($node->getAttribute('Id') == null)
                    ? $node->getAttribute('id')
                    : $node->getAttribute('Id'));
        //extrai os dados da tag para uma string na forma canonica
        $dados = $node->C14N(true, false, null, null);
        //calcular o hash dos dados
        $hashValue = hash('sha1', $dados, true);
        //converter o hash para base64
        $digValue = base64_encode($hashValue);
        //cria o node <Signature>
        $signatureNode = $xmldoc->createElementNS($nsDSIG, 'Signature');
        //adiciona a tag <Signature> ao node raiz
        $root->appendChild($signatureNode);
        //cria o node <SignedInfo>
        $signedInfoNode = $xmldoc->createElement('SignedInfo');
        //adiciona o node <SignedInfo> ao <Signature>
        $signatureNode->appendChild($signedInfoNode);
        //cria no node com o método de canonização dos dados
        $canonicalNode = $xmldoc->createElement('CanonicalizationMethod');
        //adiona o <CanonicalizationMethod> ao node <SignedInfo>
        $signedInfoNode->appendChild($canonicalNode);
        //seta o atributo ao node <CanonicalizationMethod>
        $canonicalNode->setAttribute('Algorithm', $nsCannonMethod);
        //cria o node <SignatureMethod>
        $signatureMethodNode = $xmldoc->createElement('SignatureMethod');
        //adiciona o node <SignatureMethod> ao node <SignedInfo>
        $signedInfoNode->appendChild($signatureMethodNode);
        //seta o atributo Algorithm ao node <SignatureMethod>
        $signatureMethodNode->setAttribute('Algorithm', $nsSignatureMethod);
        //cria o node <Reference>
        $referenceNode = $xmldoc->createElement('Reference');
        //adiciona o node <Reference> ao node <SignedInfo>
        $signedInfoNode->appendChild($referenceNode);
        //seta o atributo URI a node <Reference>
        $idSigned == null ? $referenceNode->setAttribute('URI', '' . $idSigned)
                          : $referenceNode->setAttribute('URI', '#' . $idSigned);
        //cria o node <Transforms>
        $transformsNode = $xmldoc->createElement('Transforms');
        //adiciona o node <Transforms> ao node <Reference>
        $referenceNode->appendChild($transformsNode);
        //cria o primeiro node <Transform> OBS: no singular
        $transfNode1 = $xmldoc->createElement('Transform');
        //adiciona o primeiro node <Transform> ao node <Transforms>
        $transformsNode->appendChild($transfNode1);
        //set o atributo Algorithm ao primeiro node <Transform>
        $transfNode1->setAttribute('Algorithm', $nsTransformMethod1);
        //cria outro node <Transform> OBS: no singular
        $transfNode2 = $xmldoc->createElement('Transform');
        //adiciona o segundo node <Transform> ao node <Transforms>
        $transformsNode->appendChild($transfNode2);
        //set o atributo Algorithm ao segundo node <Transform>
        $transfNode2->setAttribute('Algorithm', $nsTransformMethod2);
        //cria o node <DigestMethod>
        $digestMethodNode = $xmldoc->createElement('DigestMethod');
        //adiciona o node <DigestMethod> ao node <Reference>
        $referenceNode->appendChild($digestMethodNode);
        //seta o atributo Algorithm ao node <DigestMethod>
        $digestMethodNode->setAttribute('Algorithm', $nsDigestMethod);
        //cria o node <DigestValue>
        $digestValueNode = $xmldoc->createElement('DigestValue', $digValue);
        //adiciona o node <DigestValue> ao node <Reference>
        $referenceNode->appendChild($digestValueNode);
        //extrai node <SignedInfo> para uma string na sua forma canonica
        $cnSignedInfoNode = $signedInfoNode->C14N(true, false, null, null);
        //cria uma variavel vazia que receberá a assinatura
        $signature = '';
        //calcula a assinatura do node canonizado <SignedInfo>
        //usando a chave privada em formato PEM
        if (! openssl_sign($cnSignedInfoNode, $signature, $objSSLPriKey)) {
            $msg = "Houve erro durante a assinatura digital.\n";
            $this->zGetOpenSSLError($msg);
        }
        //converte a assinatura em base64
        $signatureValue = base64_encode($signature);
        //cria o node <SignatureValue>
        $signatureValueNode = $xmldoc->createElement('SignatureValue', $signatureValue);
        //adiciona o node <SignatureValue> ao node <Signature>
        $signatureNode->appendChild($signatureValueNode);
        //cria o node <KeyInfo>
        $keyInfoNode = $xmldoc->createElement('KeyInfo');
        //adiciona o node <KeyInfo> ao node <Signature>
        $signatureNode->appendChild($keyInfoNode);
        //cria o node <X509Data>
        $x509DataNode = $xmldoc->createElement('X509Data');
        //adiciona o node <X509Data> ao node <KeyInfo>
        $keyInfoNode->appendChild($x509DataNode);
        //remove linhas desnecessárias do certificado
        $pubKeyClean = $this->zCleanPubKey();
        //cria o node <X509Certificate>
        $x509CertificateNode = $xmldoc->createElement('X509Certificate', $pubKeyClean);
        //adiciona o node <X509Certificate> ao node <X509Data>
        $x509DataNode->appendChild($x509CertificateNode);
        //salva o xml completo em uma string
        $xmlResp = $xmldoc->saveXML();
        //retorna o documento assinado
        return $xmlResp;
    }
1180949
protected function processDeclaration($node, $parent) {
        $rules = [];

        foreach ($node->getRules() as $key => $rule) {
            $name = $rule->getRule();
            $seen[$name] = true;

            if (!isset(self::$rules[$name])) {
                $rules[] = $rule;
                continue;
            }

            foreach (self::$rules[$name] as $prefix) {
                $newname = $prefix . $name;
                if (isset($seen[$newname])) {
                    continue;
                }
                $newrule = clone $rule;
                $newrule->setRule($newname);
                $rules[] = $newrule;
            }

            $rules[] = $rule;
        }

        $node->setRules($this->manipulateRuleValues($rules));

        if ($node instanceof DeclarationBlock) {
            $selectors = $node->getSelectors();
            foreach ($selectors as $key => $selector) {

                $matches = [];
                if (preg_match($this->pseudosregex, $selector->getSelector(), $matches)) {

                    $newnode = clone $node;
                    foreach (self::$pseudos[$matches[1]] as $newpseudo) {
                        $newselector = new Selector(str_replace($matches[1], $newpseudo, $selector->getSelector()));
                        $selectors[$key] = $newselector;
                        $newnode = clone $node;
                        $newnode->setSelectors($selectors);
                        $parent->insert($newnode, $node);
                    }

                    // We're only expecting one affected pseudo class per block.
                    break;
                }
            }
        }
    }
1062660
protected static function process(int $jdn): array
    {
        $r = (($jdn - 1723856) % 1461);
        $n = ($r % 365) + 365 * (int) ($r / 1460);

        $year = 4 * (int) (($jdn - 1723856) / 1461) +
            (int) ($r / 365) - (int) ($r / 1460);
        $month = (int) ($n / 30) + 1;
        $day = ($n % 30) + 1;

        return compact('day', 'month', 'year');
    }
253253
public function processarLinha($numLn, Stringy $linha)
    {
        //é adicionado um espaço vazio no início_linha para que
        //possamos trabalhar com índices iniciando_1, no lugar_zero,
        //e assim, ter os valores_posição_campos exatamente
        //como no manual CNAB150
        $linha = $linha->insert(" ", 0);
        $tipoLn = $linha->substr(1, 1)->trim();

        $this->needToCreateLote = false;
        if ((string)$tipoLn == self::HEADER_ARQUIVO) {
            $this->needToCreateLote = true;
            $vlinha = $this->processarHeaderArquivo($linha);
        } else if ((string)$tipoLn == self::DETALHE) {
            $vlinha = $this->processarDetalhe($linha);
        } else if ((string)$tipoLn == self::TRAILER_ARQUIVO) {
            $vlinha = $this->processarTrailerArquivo($linha);
        }

        return $vlinha;
    }
1284346
private function listaLinhas($lista, $pulaLinha)
    {
        foreach ($lista as $d) {
            $pulaLinha -= 2;
            $this->MultiCell(0, $this->cell - 0.2, $this->_(preg_replace('/(%)/', '%$1', $d)), 0, 1);
        }

        return $pulaLinha;
    }
225915
private function processNode(\SimpleXMLElement $node): array
    {
        $config = [];
        foreach ($node as $name => $value) {
            if (\preg_match('/^num__([0-9]+)$/', $name, $matches)) {
                $name = $matches[1];
            }
            if ($value->count() > 0) {
                $config[$name] = $this->processNode($value->children());
            } else {
                $value = (string)$value;
                $config[$name] = $value;

                if (\preg_match('/^[0-9]+$/', $value)) {
                    $config[$name] = (int)$value;
                } elseif (\preg_match('/^[0-9\.]+$/', $value)) {
                    $config[$name] = (float)$value;
                } elseif (\preg_match('/^true|false$/', $value)) {
                    $config[$name] = $value === 'true' ? true : false;
                }
            }
        }
        return $config;
    }