Returns query.getParameters() {@link Observable} but only after query
dependencies have been fully emitted (and ignored).

@return query parameters
355671
static Observable<Parameter> parametersAfterDependencies(Query query) {
        return concatButIgnoreFirstSequence(query.depends(), query.parameters());
    }
403740
@Deprecated
    public List<Map<String, Object>> getQueryArgsList() {
        // simulate old implementation behavior
        List<Map<String, Object>> result = new ArrayList<Map<String, Object>>();
        for (List<ParameterSetOperation> paramsList : this.parametersList) {
            Map<String, Object> map = new HashMap<String, Object>();

            for (ParameterSetOperation param : paramsList) {
                Object[] args = param.getArgs();
                map.put(args[0].toString(), args[1]);
            }

            result.add(map);
        }
        return result;
    }
841940
def get_base(self):
    
    if self._type == 'query':
      return self._observable.get_query_base()
    return self._observable.get_target_base()
993744
public ResultSet getResults() {
        final SQLListenerContextImpl context = startContext(connection(), queryMixin.getMetadata());
        String queryString = null;
        List<Object> constants = ImmutableList.of();

        try {
            listeners.preRender(context);
            SQLSerializer serializer = serialize(false);
            queryString = serializer.toString();
            logQuery(queryString, serializer.getConstants());
            context.addSQL(getSQL(serializer));
            listeners.rendered(context);

            listeners.notifyQuery(queryMixin.getMetadata());

            constants = serializer.getConstants();

            listeners.prePrepare(context);
            final PreparedStatement stmt = getPreparedStatement(queryString);
            setParameters(stmt, constants, serializer.getConstantPaths(), getMetadata().getParams());
            context.addPreparedStatement(stmt);
            listeners.prepared(context);

            listeners.preExecute(context);
            final ResultSet rs = stmt.executeQuery();
            listeners.executed(context);

            return new ResultSetAdapter(rs) {
                @Override
                public void close() throws SQLException {
                    try {
                        super.close();
                    } finally {
                        stmt.close();
                        reset();
                        endContext(context);
                    }
                }
            };
        } catch (SQLException e) {
            onException(context, e);
            reset();
            endContext(context);
            throw configuration.translate(queryString, constants, e);
        }
    }
1269578
public Map<String, Deque<String>> getQueryParameters() {
        if (queryParameters == null) {
            queryParameters = new TreeMap<>();
        }
        return queryParameters;
    }
115504
private List<UberData> determineQueryProperties() {

		if (!getHttpMethod().equals(HttpMethod.GET)) {
			return Collections.emptyList();
		}

		if (getHttpMethod().equals(HttpMethod.GET)) {
			return getQueryMethodParameters().stream()
				.map(queryParameter -> new UberData()
					.withName(queryParameter.getName())
					.withValue(""))
				.collect(Collectors.toList());
		} else {
			return Collections.emptyList();
		}
	}
466252
synchronized public SSLParameters getSSLParameters() {
        SSLParameters params = super.getSSLParameters();

        // the super implementation does not handle the following parameters
        params.setEndpointIdentificationAlgorithm(identificationProtocol);
        params.setAlgorithmConstraints(algorithmConstraints);

        return params;
    }
856347
public List<Parameter> getAllParameters() {
        List<Parameter> ret = new ArrayList<Parameter>();

        ret.addAll(subject.getAllParameters());

        if (object != null) {
            if (object.getStatement() != null)
                ret.addAll(object.getStatement()
                        .getAllParameters());
            else
                ret.addAll(object.getTerm().getAllParameters());
        }

        return ret;
    }
840253
public Observable<ServiceResponse<ApplicationGatewayAvailableWafRuleSetsResultInner>> listAvailableWafRuleSetsWithServiceResponseAsync() {
        if (this.client.subscriptionId() == null) {
            throw new IllegalArgumentException("Parameter this.client.subscriptionId() is required and cannot be null.");
        }
        final String apiVersion = "2018-06-01";
        return service.listAvailableWafRuleSets(this.client.subscriptionId(), apiVersion, this.client.acceptLanguage(), this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<ApplicationGatewayAvailableWafRuleSetsResultInner>>>() {
                @Override
                public Observable<ServiceResponse<ApplicationGatewayAvailableWafRuleSetsResultInner>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<ApplicationGatewayAvailableWafRuleSetsResultInner> clientResponse = listAvailableWafRuleSetsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
886463
public ParameterList getQueryStringParams() {
        try {
            final ParameterList result = new ParameterList();
            final String queryString = new URL(url).getQuery();
            result.addQuerystring(queryString);
            result.addAll(querystringParams);
            return result;
        } catch (MalformedURLException mue) {
            throw new OAuthException("Malformed URL", mue);
        }
    }
800935
public java.util.Map<String, java.util.List<String>> getParameters() {
        return parameters;
    }
982276
private function buildAuthorizationQueryParameters()
    {
        $params = array(
            'response_type' => 'fragment',
            'scope' => $this->getApplicationScope(),
            'expiration' => $this->getApplicationExpiration(),
            'name' => $this->getApplicationName(),
        );

        return http_build_query($params);
    }
1072106
public Object[] getParameterValues()
    {
        Object[]  empty = new Object[0];
        if (_paramVlaues == null  ||  _paramVlaues.size() == 0) {
            return empty;
        }

        return _paramVlaues.toArray( empty );
    }
393010
def _getParameters(self):
        """"""
        param = self.query._getParameters() 
        outputNames = []
        for outputCol in self.__columns:
            outputNames.append(outputCol)            
        param.update({'colModel' : '"'+', '.join(outputNames)+'"'})        
        return param
675426
public Observable<ServiceResponse<List<TermList>>> getAllTermListsWithServiceResponseAsync() {
        if (this.client.baseUrl() == null) {
            throw new IllegalArgumentException("Parameter this.client.baseUrl() is required and cannot be null.");
        }
        String parameterizedHost = Joiner.on(", ").join("{baseUrl}", this.client.baseUrl());
        return service.getAllTermLists(this.client.acceptLanguage(), parameterizedHost, this.client.userAgent())
            .flatMap(new Func1<Response<ResponseBody>, Observable<ServiceResponse<List<TermList>>>>() {
                @Override
                public Observable<ServiceResponse<List<TermList>>> call(Response<ResponseBody> response) {
                    try {
                        ServiceResponse<List<TermList>> clientResponse = getAllTermListsDelegate(response);
                        return Observable.just(clientResponse);
                    } catch (Throwable t) {
                        return Observable.error(t);
                    }
                }
            });
    }
1170423
protected function getAllowedQueryParameters()
    {
        $queryParameters = QueryService::getDefaultQueryParameters();
        $customParameters = $this->getCustomQueryParameters();

        if (is_array($customParameters) && count($customParameters) > 0) {
            $queryParameters = array_merge($queryParameters, $customParameters);
        }

        return $queryParameters;
    }
581246
public Observable<String> getLogs() {
        return aFile != null ? aFile.getLogs() : Observable.just(null);
    }