{@inheritdoc}

@see FieldInterface::loadDataFromRequest()
16928
public function loadDataFromRequest(array $request)
    {
        foreach ($request as $key => $value) {
            if (in_array($key, $this->requestVariables)) {
                $this->data[$key] = $value;
            }
        }
    }
35590
protected function setDataFromRequest(RequestInterface $request)
    {
        $keys = $this->validDataFromRequest();
        $data = $request->getParams($keys);

        if (isset($data['obj_type'])) {
            $this->objType = $data['obj_type'];
        }

        if (isset($data['obj_id'])) {
            $this->objId = $data['obj_id'];
        }

        if (isset($data['property'])) {
            $this->propertyIdent = $data['property'];
        }

        return $this;
    }
1214185
protected function loadData(): void
	{
		$data = $this->store->read($this->sessionId);

		$this->sessionData = $data === false ? [] : $data;
	}
57938
public function loadData($printQuery = false, $logQuery = false)
    {
        if ($this->isLoaded()) {
            return $this;
        }

        $this->clear();

        foreach ($this->getResource()->getJobCodes() as $jobCode) {
            if (!empty($this->whiteList) && !in_array($jobCode, $this->whiteList)) {
                continue;
            }
            if (!empty($this->blackList) && in_array($jobCode, $this->blackList)) {
                continue;
            }

            $job = $this->getNewEmptyItem()->load($jobCode);
            if ($this->activeOnly && !$job->getIsActive()) {
                continue;
            }
            if ($this->dbOnly && !$job->isDbOnly()) {
                continue;
            }

            $this->addItem($job);
        }

        ksort($this->_items);

        $this->_setIsLoaded(true);

        return $this;
    }
1102380
protected void loadDataFromFile(File definitionFile) throws IOException {
		PHPFileParser fp = new PHPFileParser(definitionFile);
		createInternalDataStructre(fp.getSections());
	}
125426
protected function loadData($offset)
    {
        if (!$this->loaded && !$this->isNew) {
            if (is_numeric($offset) || is_null($offset)) {
                $this->findAll();
            } else {
                $this->find();
            }
        }
    }
408700
@Override
    public String loadDataFromNetwork() throws Exception {
        try {
            Ln.d("Call web service " + url);
            OkUrlFactory urlFactory = new OkUrlFactory(getOkHttpClient());
            HttpURLConnection connection = urlFactory.open(new URL(url));
            return IOUtils.toString(connection.getInputStream());
        } catch (final MalformedURLException e) {
            Ln.e(e, "Unable to create URL");
            throw e;
        } catch (final IOException e) {
            Ln.e(e, "Unable to download content");
            throw e;
        }
    }
87825
public static function load($query, $fields = null)
    {
        //
        static::applySchema();

        //
        if (is_array($query)) {
            return static::loadByQuery($query, $fields);
        }

        //
        $key = static::getPrimaryKey();

        //
        return $key
             ? static::loadByPrimaryKey($query, $fields)
             : static::loadByMainField($query, $fields);
    }
256466
private function loadParams() {
        if($this->getRequest()->getRawBody() == ''
            && empty($this->getRequest()->getPost())
            && empty($this->getRequest()->getPut())
            && empty($this->getRequest()->getUploadedFiles())
        ) {
            throw new Exception('No Data Passed', 400);
        }
        $bulkCreation = false;
        if(!is_null($this->getRequest()->getJsonRawBody())) {
            $params = $this->getRequest()->getJsonRawBody();
            $delimiter = '.';
            if(is_array($params)) {
                $bulkCreation = true;
            }
        } else {
            if($this->getRequest()->isPost()) {
                $params = $this->getRequest()->getPost();
            } else {
                $params = $this->getPut();
            }
            $delimiter = '_';
        }
        if($this->request->getRawBody()!='' && sizeOf($params) == 0 && json_last_error() != JSON_ERROR_NONE) {
            $this->dispatchJsonError();
        }
        if($bulkCreation) { //Bulk Creation
            $outputParams = [];
            foreach($params as $param) {
                $helper = new SplitHelper($delimiter);
                $outputParams[] = $helper->convert((array)$param);
            }
            $this->setParams($outputParams);
        } else {
            $helper = new SplitHelper($delimiter);
            $this->setParams($helper->convert((array)$params));
        }
    }
145653
public function loadObject($data)
    {
        if (!\is_object($data)) {
            throw new \InvalidArgumentException('param type error! must is object.');
        }

        return $this->bindData($this->data, $data);
    }
531303
public function load($data)
    {
        foreach ($data as $row) {
            $this->put($row['id'], RequestEntity::createExisting($row));
        }

        return $this;
    }
727476
protected function load(QueryBuilder $query)
    {
        $metadata = $this->getClassMetadata();
        foreach ($metadata->getFieldMappings() as $field) {
            $fieldtype = $this->getFieldManager()->get($field['fieldtype'], $field);
            if ($fieldtype instanceof FieldTypeInterface) {
                $fieldtype->load($query, $metadata);
            }
        }
    }
553261
public function loadRequestQuery($paramName)
    {
        $uri = explode('?', $this->getEnv('REQUEST_URI'));
        array_shift($uri);
        $uri = implode('?', $uri);

        /**
         * Override this method to use parsing query string PHP method
         * and not new standard of queryString
         */
        $qrs = $this->parseQueryAsMulti($uri);

        if (array_key_exists($paramName, $qrs)) {
            $this->contextDataExists = true;
            $this->contextDataValue  = $qrs[$paramName];
        }

        return $this->checkDataIsEmpty();
    }
718454
public function load($data)
    {
        $data = json_decode($data, true);

        if (JSON_ERROR_NONE !== json_last_error()) {
            throw new \RuntimeException('Error: json decode failed. ' . json_last_error_msg(), 1);
        }

        $this->setData($data);

        return $this;
    }
321206
function loadFromSession($name = '') {
		if(!$name) $name = $this->owner->FormName();

		$formSession = \Session::get("FormInfo.{$name}.data");
		if($formSession) $this->owner->loadDataFrom($formSession);
	}
1100114
public function loadObject($params=array()) {

		$this->openConnection();
		
		$obj = NULL;
		
		try {
			
			$stat = $this->handler->prepare($this->query);
			$stat->execute((array)$params);
			$obj = $stat->fetch(\PDO::FETCH_OBJ);
			
			// logger
			$this->logParamQuery($this->query, (bool)$obj, $params);

		} catch (\PDOException $e) {

			$this->handleException($e, $params);
		
		}
		
		$stat->closeCursor();

		return $obj;
		
	}
953762
public function loadRequestHeader($paramName)
    {
        $headers = $this->getRequestHeader();

        if (array_key_exists($paramName, $headers)) {
            $this->contextDataExists = true;
            $this->contextDataValue  = $headers[$paramName];
        }

        return $this->checkDataIsEmpty();
    }