Get query params list

@param  ArrayCollection $paramObj
@return array
488904
private static function getParamsArray($paramObj)
    {
        $parameters = array();
        foreach ($paramObj as $val) {
            /* @var $val \Doctrine\ORM\Query\Parameter */
            $parameters[$val->getName()] = $val->getValue();
        }

        return $parameters;
    }
648698
public function getPaginator($params = array()) 
	{
		$page = isset($params['page']) ? (int)$params['page'] : 1;
		$email = isset($params['email']) ? $params['email'] : null;
		$limit = isset($params['limit']) ? (int) $params['limit'] : 10;
		$offset = isset($params['offset']) ? (int) $params['offset'] : 0;
		
		
		$qb = $this->_em->createQueryBuilder();
		$qb->select(array('a'));
		$qb->from($this->getEntityName(), 'a');
		$qb->addOrderBy('a.dateInsert', 'DESC');
		
		if(null !== $email) {
			$qb->andWhere($qb->expr()->eq('a.email', ':paramEmail'));
			$qb->setParameter('paramEmail', $email);
		}
		
		$query = $qb->getQuery();
		$query->setFirstResult($offset);
		$query->setMaxResults($limit);
// 		$paginator = new DoctrinePaginator($query, $fetchJoinCollection = true);
// 		$result = array();
// 		foreach($paginator as $p) {
// 			$result[] = $p->getUserId();
// 		}
// 		$result = $query->getResult();
// 		$paginatorAdapter =  new RazorPaginator(
// 			$result,
// 			count($paginator)
// 		);
		$paginatorAdapter = new DoctrinePaginatorAdapter(new DoctrinePaginator($query));
		$paginator = new Paginator($paginatorAdapter);
		$paginator->setCurrentPageNumber($page);
		$paginator->setDefaultItemCountPerPage($limit);
		
		return $paginator;
	}
591343
protected function getQueryParam($param, $url) {
    $keys = [];
    $parse = parse_url($url);
    parse_str($parse['query'], $keys);

    if (isset($keys[$param])) {
      return $keys[$param];
    }

    return FALSE;
  }
1105224
@Override
    public Map<String, Object> getQueryParameters() {
        HashMap<String, Object> params = new HashMap<String, Object>();
        if (this.cascadeCreate!=null) {
            params.put("cascadeCreate", this.cascadeCreate.toString());
        }
        return params;
    }
172765
protected function getParam($param = null, $defaultValue = null)
    {
        $request = $this->getRequest();
        if ($param === null) {
            return array_merge($request->getQuery(), $request->getParams());
        }

        $value = $request->getParam($param);
        if ($value === null) {
            return $request->getQuery($param, $defaultValue);
        }

        return $value;
    }
1327813
public function getValue($params = [], $processCallbacks = true)
    {
        if ($this->isNull($this->value)) {
            // We need to load records from DB - but ONLY if parent record has an ID (otherwise no child records can exist in DB)
            $entityId = $this->parent->id;
            if (empty($entityId)) {
                // No child records exist - return an empty EntityCollection
                $this->value = new EntityCollection($this->entityClass, []);
                $this->dataLoaded = true;
            } else {
                // Try loading child records using parent id
                $query = [$this->relatedAttribute => $entityId];

                // Get optional record filters
                $filters = $this->filter;
                if (is_string($filters) || is_callable($filters)) {
                    $callable = is_string($filters) ? [$this->parent, $filters] : $filters;
                    $filters = call_user_func_array($callable, []);
                }

                // Merge optional filters with main query
                $query = array_merge($query, $filters);
                $this->value = call_user_func_array([$this->entityClass, 'find'], [$query, $this->sorter]);
                $this->dataLoaded = true;
            }
        }

        return $processCallbacks ? $this->processGetValue($this->value, $params) : $this->value;
    }
1211512
private function getAcceptedRatePlans(array $query_params = []): array
    {
        $entities = [];

        foreach ($this->getRawList($this->getAcceptedRatePlansEndpoint()->withQuery(http_build_query($query_params))) as $item) {
            /** @var \Apigee\Edge\Entity\EntityInterface $tmp */
            $tmp = $this->getEntitySerializer()->denormalize(
                $item,
                AcceptedRatePlanInterface::class,
                'json'
            );
            $entities[$tmp->id()] = $tmp;
        }

        return $entities;
    }
706
private function visitParameters(Query $query, VisitorInterface $subVisitor): array
    {
        $parametersByLanguage = [
            $query->getLocale() => iterator_to_array(
                $this->visitTranslationParameters($query, $subVisitor)
            ),
        ];

        foreach ($query->getAvailableLocales() as $availableLocale) {
            if ($availableLocale === $query->getLocale()) {
                continue;
            }

            $translatedQuery = $this->collectionService->loadQuery(
                $query->getId(),
                [$availableLocale],
                false
            );

            $parametersByLanguage[$availableLocale] = iterator_to_array(
                $this->visitTranslationParameters(
                    $translatedQuery,
                    $subVisitor
                )
            );
        }

        ksort($parametersByLanguage);

        return $parametersByLanguage;
    }
1059463
public function queryString($params = [], $format = null) {
		$result = [];
		$query = [];

		foreach (array_filter([$this->query, $params]) as $querySet) {
			if (is_string($querySet)) {
				$result[] = $querySet;
				continue;
			}
			$query = array_merge($query, $querySet);
		}
		$query = array_filter($query);

		if ($format) {
			$q = null;
			foreach ($query as $key => $value) {
				if (!is_array($value)) {
					$q .= Text::insert($format, [
						'key' => urlencode($key),
						'value' => urlencode($value)
					]);
					continue;
				}
				foreach ($value as $val) {
					$q .= Text::insert($format, [
						'key' => urlencode("{$key}[]"),
						'value' => urlencode($val)
					]);
				}
			}
			$result[] = substr($q, 0, -1);
		} else {
			$result[] = http_build_query($query);
		}

		$result = array_filter($result);
		return $result ? "?" . join("&", $result) : null;
	}
460119
protected function _getParams()
    {
        $aResult = array();
        $aParams = (array)$this->_getContainer()->getConfig()->getRequestParameter('aParams');

        foreach ($aParams as $sKey => $sValue) {
            $aResult[html_entity_decode($sKey)] = html_entity_decode($sValue);
        }

        return $aResult;
    }
521874
public function queryDocument($collection, $sql, array $params = [], array $options = [])
    {
        $this->setOptions($options);
        $doc = new Document($this->client, $this->database, $collection);
        $doc->setHeaders($this->getHeaders());
        $rs = $doc->query($sql, $params);
        $this->checkResponse($rs);
        unset($rs['_curl_info']);

        return $rs;
    }
689560
protected function getItemParams(Row $row, array $params_list)
	{
		$return = [];

		foreach ($params_list as $param_name => $param) {
			$return[is_string($param_name) ? $param_name : $param] = $row->getValue($param);
		}

		return $return;
	}
776763
private function getMutationQueryParams($options = [])
    {
        $query = ['returnIds' => 'true'];

        if (!isset($options['returnDocuments']) || $options['returnDocuments']) {
            $query['returnDocuments'] = 'true';
        }

        if (isset($options['visibility']) && $options['visibility'] !== 'sync') {
            $query['visibility'] = $options['visibility'];
        }

        return $query;
    }
1288722
private function buildArgumentArray(array $params, ArrayCollection $methodArguments)
    {
        $arguments = [];

        $sort = Criteria::create();
        $sort->orderBy(['order' => Criteria::ASC]);
        $methodArguments = $methodArguments->matching($sort);

        for ($i = 0; $i < count($params); $i++) {
            if (!isset($methodArguments[$i])) {
                break;
            }

            /** @var \ReflectionParameter $param */
            $param = $params[$i];

            /** @var ArgumentDocument $argument */
            $argument = $methodArguments[$i];

            $callback = $argument->getCallback();
            $value = $argument->getValue();

            $argumentValue = null;
            if (null !== $callback) {
                $argumentValue = $this->call($callback);
            } else if (null !== $value) {
                $argumentValue = $argument->getValue();
            } else {
                throw new MissingMethodArgumentException(
                    sprintf(
                        'The argument at position %d has no value or callback defined',
                        $argument->getOrder()
                    )
                );
            }

            $paramType = $param->getClass();
            if (null !== $paramType || is_object($argumentValue)) {
                if (null !== $paramType) {
                    $paramType = $paramType->getName();
                }

                $argumentType = null;
                if (is_object($argumentValue)) {
                    $argumentType = get_class($argumentValue);
                }

                if ($argumentType !== $paramType) {
                    throw new BadArgumentTypeException(
                        sprintf(
                            'The argument at position %d was expected to be of type "%s"',
                            $argument->getOrder(),
                            $paramType
                        )
                    );
                }
            }

            $arguments[] = $argumentValue;
        }

        return $arguments;
    }
153025
public static function get($params = array())
	{
		$object = new static;
		$data   = $object->request('GET', $object->getUrl(), $params);
		$data   = $object->stripResponseData($data);

		// Initialise a collection
		$collection = self::newCollection();

		if (isset($data[0]) && is_array($data[0])) {
			// This should be a collection
			$collection->setItems($data);
		}

		return $collection;
	}
857519
public function getPages(ECParams $params)
    {
        $stmtManager = $this->getStatementManager(Simple::class);

        /** @var Select $stmtBuilder */
        $stmtBuilder = $stmtManager->getStatementBuilder(Select::class);

        /** @var PageCollection $collection */
        $collection = $stmtManager->setStatement($stmtBuilder->setColumns(['stub']))
            ->execute();

        return $collection->setEcParams($params);
    }
225482
@Override
    public Map<String, Object> getQueryParameters() {
        HashMap<String, Object> params = new HashMap<String, Object>();
        return params;
    }