Get all data from model

@return array
175150
public function beginAll()
    {
        $this->startProfiling();

        $result = parent::beginAll();

        $this->endProfiling('beginAll', $result);
        $this->clearParams();

        return $result;
    }
980201
protected function getModels()
    {
        if ($this->_models === null) {
            $this->_models = [];
            $timings = $this->calculateTimings();

            foreach ($timings as $seq => $dbTiming) {
                $this->_models[] = [
                    'method' => $this->getRequestMethod($dbTiming['info']),
                    'type' => $this->getRequestType($dbTiming['category']),
                    'request' => $dbTiming['info'],
                    'duration' => ($dbTiming['duration'] * 1000), // in milliseconds
                    'trace' => $dbTiming['trace'],
                    'timestamp' => ($dbTiming['timestamp'] * 1000), // in milliseconds
                    'seq' => $seq,
                ];
            }
        }

        return $this->_models;
    }
310548
public function getAll(){
        $rest = $this->getService( self::API_UPLOAD);
        $rest->GET();

        return $rest->getResultAsArray( models\FileSystem\FileUpload::class);
    }
1369503
public function getAll(): array
    {
        $namespace = $this->getNamespace();
        $length = mb_strlen($namespace);

        $values = [];

        $data = $this->session->getAll();
        foreach ($data as $key => $val) {
            if (mb_substr($key, 0, $length) === $namespace) {
                $key = mb_substr($key, $length);
                $values[$key] = $val;
            }
        }

        return $values;
    }
655262
protected function getData()
    {
        if (empty($this->data) || !is_array($this->data)) {
            $this->init();
        }

        return $this->data;
    }
1361079
public function getModels()
    {
        // First, we will simply get the raw results from the query builders which we
        // can use to populate an array with Eloquent models. We will pass columns
        // that should be selected as well, which are typically just everything.
        $results = $this->query->get();

        $connection = $this->model->getConnectionName();

        $models = [];

        // Once we have the results, we can spin through them and instantiate a fresh
        // model instance for each records we retrieved from the database. We will
        // also set the proper connection name for the model after we create it.
        foreach ($results as $result) {
            $models[] = $model = $this->model->newFromBuilder($result);

            $model->setConnection($connection);
        }

        return $models;
    }
764943
protected function getData()
    {
        $data = [];
        $fields = $this->getDescriptor()->getFields();
        /** @var FieldDescriptor $field */
        foreach ($fields as $field) {
            $data[$field->getField()] = $this->entity->{$field->getName()};
        }
        return $data;
    }
299607
protected function getProviderData()
    {
        $models = $this->data->getModels();
        $data = [];
        foreach ($models as $model) {
            $row = $model instanceof Model ? $model->attributes : $model;
            if ($this->attributes) {
                $values = [];
                foreach ($this->attributes as $attr) {
                    $values[$attr] = $row[$attr];
                }
                $row = $values;
            }
            $data [] = array_values($row);
        }
        return $data;
    }
1220155
protected function getData()
    {
        $appended   = $this->getAppends();
        $properties = $this->getProperties();

        // Data
        $result = [];
        foreach ($properties as $property) {
            $alias = $this->getName($property);
            $model = $this->getModel();
            $result[$alias] = $model->$property;
        }

        // Appends
        foreach ($appended as $name => $callback) {
            $result[$name] = $callback($this->getModel());
        }

        return $result;
    }
733156
public function getAll () : array
    {
        return array_map(
            function (string $key)
            {
                return $this->getType($key);
            },
            array_keys($this->types)
        );
    }
863305
public function getData()
    {
        foreach ($this->data as $value) {
            $this->validateDefinitions($value);
        }
        return ['data' => $this->data, 'parent_aliases' => $this->parentAliases];
    }
1013741
protected function getConnectionData()
	{
		return [$this->associativeLocal => $this->model->getPkValue(), $this->shifter => strtolower($this->model->getModelName())];
	}
1345098
public function getAll()
    {
        $data = [];
        foreach ($this->pluginClasses as $id => $class) {
            $plugin = $this->getById($id);
            if ($plugin) {
                $data[] = $plugin;
            }
        }

        return $data;
    }
1144850
public function fetchAll()
    {
        $query = sprintf('SELECT * FROM `%s`', $this->table);
        $result = array();

        foreach ($this->pdo->query($query) as $key => $value) {
            $result[$key] = $value;
        }

        return $this->parse($result);
    }
507800
public function getData()
    {
        if ($this->data === null) {
            $searchRequest  = $this->searchRequestBuilder->getRequest();
            $searchResponse = $this->searchEngine->search($searchRequest);

            $this->data = $this->processResponse($searchResponse);
        }

        return $this->data;
    }
25824
public function getData() : array
    {
        $data = [];
        $request = $this->getRequest();
        $method = $request->getMethod();

        switch ($method) {

            //GET
            case Request::METHOD_GET:
                $data = $_GET ?: [];
            break;

            //POST
            case Request::METHOD_POST:
                $data = $_POST ?: [];
            break;

            //Other supported
            case Request::METHOD_DELETE:
            case Request::METHOD_PUT:
            case Request::METHOD_PATCH:
                parse_str($request->getRequestBody(), $data);
            break;

        }

        return $data;
    }
303503
public function getData()
    {
        $fieldsets = $this->grid->fieldsets;
        $controls  = [];
        foreach ($fieldsets as $fieldset) {
            foreach ($fieldset->controls() as $control) {
                array_push($controls, $control->name);
            }
        }
        $keys = $this->resolveWithMultiples($controls);
        return array_only(inputs(), $keys);
    }