Fill
@return void
12523
public function Fill()
	{
		if ( $this->src->getIsFinished() ) return;

		foreach ( $this->src as $fact )
		{
			$this->buffer[] = $fact;
		}
		// while ( $this->src->MoveNext() )
		// {
		// 	$this->buffer[] = $this->src->getCurrent();
		// }

		$this->filled = true;
		$this->empty = ! count( $this->buffer );
	}
1044244
public function fill($success, $statusCode, $statusText, $response)
    {
        $this->success = $success;
        $this->statusCode = $statusCode;
        $this->statusText = $statusText;
        $this->response = $response;
    }
610652
protected function fill()
    {
        $this->primaryKeys = $this->blueprint->primaryKey();

        // Process columns
        foreach ($this->blueprint->columns() as $column) {
            $this->parseColumn($column);
        }

        if (! $this->loadRelations) {
            return;
        }

        foreach ($this->blueprint->relations() as $relation) {
            $model = $this->makeRelationModel($relation);
            $belongsTo = new BelongsTo($relation, $this, $model);
            $this->relations[$belongsTo->name()] = $belongsTo;
        }

        foreach ($this->factory->referencing($this) as $related) {
            $factory = new ReferenceFactory($related, $this);
            $references = $factory->make();
            foreach ($references as $reference) {
                $this->relations[$reference->name()] = $reference;
            }
        }
    }
303475
public function fill(array $data)
    {
        /* @var Field $field */
        foreach ($this->fields() as $field) {
            $field->fill($data);
        }

        return $this;
    }
103052
public function populate()
    {
        foreach ($this->languages as $language => $key) {
            $contents = $this->contentRepository->findByContentTypeAndCondition($language);

            $this->multipleIndexor->indexMultiple($contents);
        }
    }
1317032
protected function _fillup($max)
    {
        $nb = $max - $this->_running;
        $list = array_splice($this->_queue, 0, $nb);
        foreach ($list as $item) {
            $handle = $this->_initRequest($item['socket'], $item['response']);
            $this->_handles[(integer) $handle] = $item;
            curl_multi_add_handle($this->_curl, $handle);
        }
    }
567665
public function load_data() {
        global $DB;

        // Load the field object.
        if (($this->fieldid == 0) or (!($field = $DB->get_record('user_info_field', array('id' => $this->fieldid))))) {
            $this->field = null;
            $this->inputname = '';
        } else {
            $this->set_field($field);
        }

        if (!empty($this->field) && $this->userid > 0) {
            $params = array('userid' => $this->userid, 'fieldid' => $this->fieldid);
            if ($data = $DB->get_record('user_info_data', $params, 'data, dataformat')) {
                $this->set_user_data($data->data, $data->dataformat);
            }
        } else {
            $this->data = null;
        }
    }
1163084
protected function fillUsername(string $username): void
    {
        $this->context->findElement($this->fields['username'], $this->defaultTimeout)->setValue($username);
    }
397910
public function fill(array $values)
	{
		foreach ($values as $key => $value)
		{
			callback($this, 'fill' . ucfirst($key))->invoke($value);
		}
		return $this;
	}
964207
private function fill() {

        //Prefill value
        if(true === $this -> filled) {

            if(true === isset($this -> attributes['name'])) {

                if(true === Request :: isPost()) {
                    $this -> attributes['value'] = Request :: fromPost($this -> attributes['name']);
                }
            }
        }
    }
521450
protected function fillDataForEmpty()
    {
        // Fill list references if they are empty
        $fields = [];

        // Add fields for attributes
        foreach ($this->info->attributes as $attribute) {

            if ($attribute->hidden || ! $this->shouldAttributeBeDisplayedByDefault($attribute, $this->info)) {
                continue;
            }

            $fields[ $attribute->name ] = $this->makeModelShowFieldDataForAttributeData($attribute, $this->info);
        }

        // Add fields for relations?
        // Perhaps, though it may be fine to leave this up to manual configuration.
        // todo: consider


        $this->info->show->fields = $fields;
    }
585529
public function addConstraints()
    {
        if (static::$constraints) {
            parent::addConstraints();

            $this->query->where($this->morphType, $this->morphClass);
        }
    }
626915
function fill() {

        if (self.pgrid.filteredDataSource != null && self.dimensionsCount > 0) {

            var datasource = self.pgrid.filteredDataSource;
            if (datasource != null && utils.isArray(datasource) && datasource.length > 0) {
                for (var rowIndex = 0, dataLength = datasource.length; rowIndex < dataLength; rowIndex++) {
                    var row = datasource[rowIndex];
                    var dim = self.root;
                    for (var findex = 0; findex < self.dimensionsCount; findex++) {
                        var depth = self.dimensionsCount - findex;
                        var subfield = self.fields[findex];
                        var subvalue = row[subfield.name];
                        var subdimvals = dim.subdimvals;

                        if (subdimvals[subvalue] !== undefined) {
                            dim = subdimvals[subvalue];
                        } else {
                            dim.values.push(subvalue);
                            dim = new Dimension(++dimid, dim, subvalue, subfield, depth, false, findex == self.dimensionsCount - 1);
                            subdimvals[subvalue] = dim;
                            dim.rowIndexes = [];
                            self.dimensionsByDepth[depth].push(dim);
                        }

                        dim.rowIndexes.push(rowIndex);
                    }
                }
            }
        }
    }
379774
public function fillFromPost()
    {
        $id = str_replace('\\', '_', get_class($this));
        if ($data = \Devil::app()->post->getOnce($id)) {
            unset($data[$this->getRoleValue('id')]);
            $this->setAttributes($data);
            return true;
        }
        return false;
    }
548452
private function populate()
    {
        foreach ($this->words as $word) {
            $rowOrColumn = rand(1, 2);

            if ($rowOrColumn == 1) {
                shuffle($this->rowsAvailable);

                foreach ($this->rowsAvailable as $key => $row) {
                    $maxStart = ($this->size - Utils::stringLength($word));
                    $startOptions = Utils::integerAsOptions($maxStart);
                    foreach ($startOptions as $startIndex) {
                        if ($this->tryWordInRow($word, $row, $startIndex)) {
                            $this->insertWordIntoRow($word, $row, $startIndex);
                            unset($this->rowsAvailable[$key]);
                            break(2);
                        }
                    }
                }
            } else {
                shuffle($this->columnsAvailable);

                foreach ($this->columnsAvailable as $key => $column) {
                    $maxStart = ($this->size - Utils::stringLength($word));
                    $startOptions = Utils::integerAsOptions($maxStart);
                    foreach ($startOptions as $startIndex) {
                        if ($this->tryWordInColumn($word, $column, $startIndex)) {
                            $this->insertWordIntoColumn($word, $column, $startIndex);
                            unset($this->columnsAvailable[$key]);
                            break(2);
                        }
                    }
                }
            }
        }
    }
1155832
public function load()
    {
        $contents = $this->client->get($this->key);

        if ($contents !== null) {
            $this->setFromStorage($contents);
        }
    }
772451
protected function fillItems()
    {
        $migrations = [];
        foreach (Directory::iterator($this->folder) as $file) {
            $class = $this->namespace . '\\' . Str::cut($file->getFilename(), '.php');
            $model = Model::fromClass($class);
            if ($this->mustBeFiltered($model)) {
                continue;
            }
            $migrations[] = $model;
        }

        $migrations = $this->sort($migrations);

        $this->items = $this->onlyOne
            ? count($migrations) ? [$migrations[0]] : []
            : ($this->last === null
                ? $migrations
                : Arr::last($migrations, $this->last)
            );
    }