Transform a list of general {@link QueryParameter}s into a list of {@link CollectionJsonData} objects.

@return
350060
private List<CollectionJsonData> determineQueryProperties() {

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

		return getQueryMethodParameters().stream() //
				.map(queryProperty -> new CollectionJsonData() //
						.withName(queryProperty.getName()) //
						.withValue("")) //
				.collect(Collectors.toList());
	}
479975
public List<T> query(String query, QueryType type)
    {
        switch (type)
        {
        case JPQL:
            return query(query);

        case NATIVE:
            return nativeQuery(query);

        default:
            throw new KunderaException("invalid query type");
        }
    }
582993
public List<List<Object>> getParameterSets() {
        List<List<Object>> result = new LinkedList<>();
        if (routeUnit.getSqlUnit().getParameters().isEmpty() || 0 == actualCallAddBatchTimes) {
            result.add(Collections.emptyList());
        } else {
            result.addAll(Lists.partition(routeUnit.getSqlUnit().getParameters(), routeUnit.getSqlUnit().getParameters().size() / actualCallAddBatchTimes));
        }
        return result;
    }
747724
@SuppressWarnings("unchecked")
    @Override
    public final Collection<V> getAll(final PaginationData pagination) {
        final Query builtQuery; // Query created from the query data

        checkNotNull(pagination,
                "Received a null pointer as the pagination data");

        // Builds the query
        builtQuery = getEntityManager().createQuery(getAllValuesQuery());

        // Sets the pagination
        applyPagination(builtQuery, pagination);

        // Processes the query
        return builtQuery.getResultList();
    }
794473
public QueryBuilder map(String query, String method_name, Object... items) throws Exception {
        JSONObject op = new JSONObject();
        if (query != null)
            op.put(Constants.REQUEST_QUERY, query);

        java.util.Map<String, Object> operation = new LinkedHashMap<String, Object>();
        operation.put(Constants.REQUEST_METHOD_NAME, method_name);

        if (query != null)
            queryStringRepresentation += query;

        queryStringRepresentation += "." + method_name;

        operation.put(Constants.REQUEST_ARGUMENTS, buildArgsArray(items));
        op.put(Constants.REQUEST_OPERATION, operation);

        JSONArray operations = (JSONArray) request.get(Constants.REQUEST_OPERATIONS);
        operations.put(op);
        request.remove(Constants.REQUEST_OPERATIONS);
        request.put(Constants.REQUEST_OPERATIONS, operations);

        return this;
    }
759150
@NonNull
    @Override
    public List<Object> toList() {
        final List<Object> array = new ArrayList<>();
        for (int i = 0; i < count(); i++) {
            array.add(values.get(i).asObject());
        }
        return array;
    }
1052344
public static Collection<SearchResultDTO> searchResultDTOs(SearchResults results) {
        return Lists.newArrayList(Iterables.transform(results, new Function<SearchResults.Result, SearchResultDTO>() {
            @Override
            public SearchResultDTO apply(Result input) {
                return new SearchResultDTO(
                        new ResourceDTO(input.getResource().getId(), unwrapMap(input.getResource().getAttributes())),
                        input.getMetrics());
            }
        }));
    }
314121
public Iterator<QueryParameters> iterator() {
        final QueryParametersLazyList source = this;

        return new Iterator<QueryParameters>() {
            private LazyCacheIterator<QueryParameters> lazyCacheIterator = source.getLazyCacheIterator(-1);

            public boolean hasNext() {
                return lazyCacheIterator.hasNext();
            }

            public QueryParameters next() {
                return lazyCacheIterator.getNext();
            }

            public void remove() {
                source.remove(currentIndex);
            }
        };
    }
913670
public List<FilterMappingType<WebAppType<T>>> getAllFilterMapping()
   {
      List<FilterMappingType<WebAppType<T>>> list = new ArrayList<FilterMappingType<WebAppType<T>>>();
      List<Node> nodeList = childNode.get("filter-mapping");
      for(Node node: nodeList)
      {
         FilterMappingType<WebAppType<T>>  type = new FilterMappingTypeImpl<WebAppType<T>>(this, "filter-mapping", childNode, node);
         list.add(type);
      }
      return list;
   }
1269578
public Map<String, Deque<String>> getQueryParameters() {
        if (queryParameters == null) {
            queryParameters = new TreeMap<>();
        }
        return queryParameters;
    }
1242031
public Collection<Parameter<?>> getParameters() {
        if (_parameters == null) {
            return Collections.<Parameter<?>>emptyList();
        }
        
        return Collections.unmodifiableCollection(_parameters);
    }
981244
@SuppressWarnings("deprecation")
	public static Map<String, List<String>> convert(WebQuery query)
	{
		MultivaluedHashMap<String, String> map = new MultivaluedHashMap<>();

		map.putSingle(WQUriControlField.FETCH.getName(), query.fetch);

		if (query.dbfetch != null)
			map.putSingle(WQUriControlField.DBFETCH.getName(), query.dbfetch);

		if (query.expand != null)
			map.put(WQUriControlField.EXPAND.getName(), list(query.expand));

		map.put(WQUriControlField.ORDER.getName(),
		        query.orderings.stream().map(WQOrder:: toLegacyForm).collect(Collectors.toList()));

		if (query.getOffset() > 0)
			map.putSingle(WQUriControlField.OFFSET.getName(), String.valueOf(query.getOffset()));

		map.putSingle(WQUriControlField.LIMIT.getName(), String.valueOf(query.getLimit()));

		if (query.constraints.computeSize)
			map.putSingle(WQUriControlField.COMPUTE_SIZE.getName(), String.valueOf(query.constraints.computeSize));
		if (query.constraints.subclass != null)
			map.put(WQUriControlField.CLASS.getName(), list(query.constraints.subclass));

		addConstraints(map, query.constraints);

		return map;
	}
288053
public Map<String, Object> getParams() {
    return (null == params) ? Conditions.getParamMap(conditions) : CollectUtils.newHashMap(params);
  }
1042917
@Override
    public List<Metric> transform(QueryContext queryContext, List<Metric>... listOfList) {
        List<Metric> result = new ArrayList<>();

        for (List<Metric> list : listOfList) {
            for (Metric metric : list) {
                result.add(metric);
            }
        }
        return result;
    }
1094080
public java.util.List<ParameterObject> getParameterObjects() {
        if (parameterObjects == null) {
            parameterObjects = new com.amazonaws.internal.SdkInternalList<ParameterObject>();
        }
        return parameterObjects;
    }
322726
public Map<String, Collection<String>> toMap() {
        Map<String, Collection<String>> params = new HashMap<String, Collection<String>>();
        if (null != type) {
            ArrayList<String> valueList = new ArrayList<String>();
            valueList.add(type);
            params.put("type", valueList);
        }
        if (null != data) {
            ArrayList<String> valueList = new ArrayList<String>();
            valueList.add(data);
            params.put("data", valueList);
        }

        return params;
    }
819787
@Override
    public List<DistinctQueryResult> divide() {
        return Lists.newArrayList(Iterators.transform(getResultData(), new Function<QueryRow, DistinctQueryResult>() {
    
            @Override
            public DistinctQueryResult apply(final QueryRow input) {
                Set<QueryRow> resultData = new LinkedHashSet<>();
                resultData.add(input);
                return new AggregationDistinctQueryResult(getColumnLabelAndIndexMap(), resultData.iterator(), metaData);
            }
        }));
    }