Devolve os dados estruturados para estilização.

@return array
545336
public function getBuffer() : array
    {
        if($this->buffer !== null) {
            return $this->buffer;
        }

        $this->buffer = [];
        foreach ($this->reader->toArray() as $row => $children) {
            if(isset($this->buffer[$row]) == false) {
                $this->buffer[$row] = [];
            }

            foreach ($children as $col => $value) {
                $this->buffer[$row][$col] = [
                    'value' => $value,
                    'styles' => []
                ];
            }
        }

        return $this->buffer;
    }
260748
public function deriveColumns()
    {
        $derived = array();
        
        for ($i = 0; $i < count($this->columns); $i ++) {
            $derived[] = $this->deriveColumn($i);
        }
        
        return $derived;
    }
1102857
protected function getDeletedEventAttributes(): array
    {
        $old = [];

        foreach ($this->attributes as $attribute => $value) {
            if ($this->isAttributeAuditable($attribute)) {
                $old[$attribute] = $value;
            }
        }

        return [
            $old,
            [],
        ];
    }
560776
private function addDemoContentOperations() {
    $operations = [];

    $contentDefs = $this->demoContentManager->getFilteredDefinitions(
      DemoContentTypes::ECOMMERCE
    );

    // Add module install task to install our commerce exports module.
    $operations[] = [
      [static::class, 'installDependency'],
      [
        'presto_commerce',
        DependencyTypes::MODULE,
      ],
    ];

    // Run any further content tasks.
    foreach ($contentDefs as $def) {
      $operations[] = [
        [static::class, 'createDemoContent'],
        [$def['id']],
      ];
    }

    return $operations;
  }
1299624
public function getMethods()
    {
        //todo cache
        $result = array();
        foreach ($this->getReflectionClass()->getMethods() as $m)
        {
            $result[] = MethodInfo::__internal_create($this, $m);
        }
        return $result;
    }
1197989
protected function getRevertFileContents()
    {
        $lines = [];

        $sp = "    ";

        // DESEMPACOTADORES RANDÔMICOS:
        // São várias funções 'falsas' com nomes ramdômicos que,
        // internamente, invocam as funções reais de desempacotamento.
        // Apenas para dificultar o entendimento do hacker :)
        //
        // As chaves e valores são no formato 'desempacotador => metodo'.
        // Ex.:
        // 'cfForgetShow'  => 'packerOne',
        // 'cryptOf'       => 'packerTwo',
        foreach($this->map_packer_functions as $packer_name => $method_name) {
            // Renomeia o prefixo do método 'packerOne'
            // para nomear na função de desempacotamento como 'baseOne'
            $base_name = str_replace('packer', 'base', $method_name);

            $lines[] = "if (function_exists('{$packer_name}') == false){\n"
                     . $sp . "function {$packer_name}(\$data, \$revert = false){\n"
                     . $sp .$sp . "return {$base_name}(\$data);\n"
                     . $sp . "}\n"
                     . "}";
        }

        // DESEMPACOTADORES REAIS:
        // Os desempacotadores randômicos invocam três 'efetivos':
        // baseOne, baseTwo e baseThree
        $bases = array_unique($this->map_packer_functions);
        foreach($bases as $method_name) {
            // Renomeia o prefixo do método 'packerOne'
            // para nomear na função de desempacotamento como 'baseOne'
            $base_name = str_replace('packer', 'base', $method_name);
            $lines[] = "if (function_exists('{$base_name}') == false){\n"
                     . $sp . "function {$base_name}(\$data)\n"
                     // Extrai o conteúdo do método 'packer???Unpack'
                     // para gerar a função 'base???'
                     . $this->extractMethod($method_name . 'Unpack')
                     . "}";
        }

        // ARGUMENTADORES RAMDÔMICOS:
        // São várias funções 'falsas' com nomes ramdômicos que,
        // internamente apenas devolvem uma valor booleano e que
        // serão usadas como argumentos da função desempacotadora
        //
        // Veja como isso é feito no método wrapString
        foreach($this->map_argumenter_functions as $method_name) {
            $lines[] = "if (function_exists('{$method_name}') == false){\n"
                     . $sp . "function {$method_name}() { return TRUE; }\n"
                     . "}";
        }

        return implode("\n", $lines);
    }
172253
public function flattenCases(): array
    {
        $dict = [];
        foreach ($this->getCases() as $case) {
            if (!isset($dict[$case->file])) {
                $dict[$case->file] = new TestSuite($case->class, 0, 0, 0, 0, 0, 0);
            }
            $dict[$case->file]->cases[] = $case;
            ++$dict[$case->file]->tests;
            $dict[$case->file]->assertions += $case->assertions;
            $dict[$case->file]->failures += \count($case->failures);
            $dict[$case->file]->errors += \count($case->errors);
            $dict[$case->file]->skipped += \count($case->skipped);
            $dict[$case->file]->time += $case->time;
            $dict[$case->file]->file = $case->file;
        }

        return array_values($dict);
    }
1210562
protected function getStrategyClasses()
    {
        $result = array();

        // For now hardcoded, but this can be turned into a discovery.
        $namespace = '\Siel\Acumulus\Invoice\CompletorStrategy';
        $result[] = "$namespace\\ApplySameVatRate";
        $result[] = "$namespace\\SplitKnownDiscountLine";
        $result[] = "$namespace\\SplitLine";
        $result[] = "$namespace\\SplitNonMatchingLine";
        $result[] = "$namespace\\TryAllVatRatePermutations";

        usort($result, function($class1, $class2) {
           return $class1::$tryOrder - $class2::$tryOrder;
        });

        return $result;
    }
81419
public function getChildrenUpdaters(): array {
        $key = get_class($this);
        if(!array_key_exists($key, self::$childrenUpdaters)) {
            return [];
        }
        return self::$childrenUpdaters[$key];
    }
146018
public function getDeletedExtensions()
    {
        $oModuleValidatorFactory = $this->getModuleValidatorFactory();
        $oModuleMetadataValidator = $oModuleValidatorFactory->getModuleMetadataValidator();
        $aModulesIds = $this->getModuleIds();
        $oModule = $this->getModule();
        $aDeletedExt = [];

        foreach ($aModulesIds as $sModuleId) {
            $oModule->setModuleData(['id' => $sModuleId]);
            if (!$oModuleMetadataValidator->validate($oModule)) {
                $aDeletedExt[$sModuleId]['files'] = [$sModuleId . '/metadata.php'];
            } else {
                $aInvalidExtensions = $this->_getInvalidExtensions($sModuleId);
                if ($aInvalidExtensions) {
                    $aDeletedExt[$sModuleId]['extensions'] = $aInvalidExtensions;
                }
            }
        }

        return $aDeletedExt;
    }
1106199
public function getDevImplementations(){

        $returnValue = array();

        $hookFileName = $this->getHookFileName();

        foreach(glob($this->getBaseDevDir().'*/'.$hookFileName.'.js') as $file){

            $dir = str_replace($hookFileName.'.js', '', $file);
            $manifestFile = $dir.$hookFileName.'.json';

            if(file_exists($manifestFile)){

                $typeIdentifier = basename($dir);
                $baseUrl = $this->getBaseDevUrl().$typeIdentifier.'/';
                $manifest = json_decode(file_get_contents($manifestFile), true);
                
                $returnValue[] = array(
                    'typeIdentifier' => $typeIdentifier,
                    'label' => $manifest['label'],
                    'directory' => $dir,
                    'baseUrl' => $baseUrl,
                    'file' => $this->getEntryPointFile($typeIdentifier),
                    'manifest' => $manifest,
                    'dev' => true,
                    'debug' => (isset($manifest['debug']) && $manifest['debug']),
                    'registry' => get_class($this)
                );
            }
        }

        return $returnValue;
    }
723719
public function get_arrayOcorrencias(){
        $detalhes = new DetalhaMovimentoRetorno('033','240');

        $codigoMovimento = str_pad($this->data['codigo_movimento'], 2, 0, STR_PAD_LEFT);

        return $detalhes->getArrayTxtOcorrencias($codigoMovimento, $this->data['codigo_ocorrencia']);
    }
308417
public function getPatchResolvers()
    {
        $resolvers = [];
        $plugin_manager = $this->composer->getPluginManager();
        foreach ($plugin_manager->getPluginCapabilities(
            'cweagans\Composer\Capability\ResolverProvider',
            ['composer' => $this->composer, 'io' => $this->io]
        ) as $capability) {
            /** @var ResolverProvider $capability */
            $newResolvers = $capability->getResolvers();
            if (!is_array($newResolvers)) {
                throw new \UnexpectedValueException(
                    'Plugin capability ' . get_class($capability) . ' failed to return an array from getResolvers().'
                );
            }
            foreach ($newResolvers as $resolver) {
                if (!$resolver instanceof ResolverBase) {
                    throw new \UnexpectedValueException(
                        'Plugin capability ' . get_class($capability) . ' returned an invalid value.'
                    );
                }
            }
            $resolvers = array_merge($resolvers, $newResolvers);
        }

        return $resolvers;
    }
1024784
public function getEnumerators(): array
    {
        $enumeration = $this->enumeration;
        $enumerators = [];
        foreach ($this->getOrdinals() as $ord) {
            $enumerators[] = $enumeration::byOrdinal($ord);
        }
        return $enumerators;
    }
503826
public function getDependencies()
    {
        $dependencies = array();

        $file = $this->getFilePath();
        if ($file) {
            $dependencies[] = $file;
        }

        foreach ($this->operations as $operation) {
            foreach ($operation[1] as $argument) {
                if ($argument instanceof self) {
                    $dependencies = array_merge($dependencies, $argument->getDependencies());
                }
            }
        }

        return $dependencies;
    }
544159
private function getWhereClause(): array
    {
        $result = array_merge($this->getOwnerFields(), $this->getBelongTo(), $this->getPermissions());
        $result = array_merge($result, $this->getParentPermissions(), $this->getParentJoinsWhereClause());
        $result = array_merge_recursive($result, $this->getSupervisorWhereClause());

        return $result;
    }
618275
protected function sortResolvers()
    {
        $sortedResolvers = array();
        krsort($this->resolvers);

        foreach ($this->resolvers as $resolvers) {
            $sortedResolvers = array_merge($sortedResolvers, $resolvers);
        }

        return $sortedResolvers;
    }