import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
/**
 * Build a {@link Query} using the Datastore and configuring query filters and sorts.
 * @param configuration Query configuration
 * @param withSorts Whether to apply sorts, if any, to query
 * @return Query instance
 */
protected Query buildQuery(QueryConfigurationProvider configuration, boolean withSorts) {
	Query q = getDatastore().query();
	// target
	if (getTarget() != null) {
		q.target(getTarget());
	}
	// filter
	QueryFilter filter = configuration.getQueryFilter();
	if (filter != null) {
		q.filter(filter);
	}
	// sort
	if (withSorts) {
		QuerySort sort = configuration.getQuerySort();
		if (sort != null) {
			q.sort(sort);
		}
	}
	// parameters
	ParameterSet parameters = configuration.getQueryParameters();
	if (parameters != null) {
		parameters.forEachParameter((n, v) -> q.parameter(n, v));
	}
	return q;
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Test
public void testQueryDefinition() {

	DefaultQueryDefinition qd = new DefaultQueryDefinition();
	qd.setTarget(DataTarget.named("target"));

	assertTrue(qd.getTarget().isPresent());
	assertEquals("target", qd.getTarget().get().getName());

	qd.setLimit(Integer.valueOf(10));
	qd.setOffset(Integer.valueOf(20));

	assertTrue(qd.getLimit().isPresent());
	assertTrue(qd.getLimit().isPresent());
	assertEquals(new Integer(10), qd.getLimit().get());
	assertEquals(new Integer(20), qd.getOffset().get());

	qd.addFilter(TestPropertySet.NAME.isNotNull());
	assertTrue(qd.getFilter().isPresent());

	QuerySort qs = TestPropertySet.NAME.asc();
	qd.addSort(qs);
	assertEquals(qs, qd.getSort().get());

}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
protected QueryConfigurationProvider getConfiguration(final Query<ITEM, QueryFilter> query) {
	final QueryFilter filter = query.getFilter().orElse(null);

	final List<QuerySort> sorts = new LinkedList<>();
	List<QuerySortOrder> orders = query.getSortOrders();
	if (orders != null && !orders.isEmpty()) {
		orders.forEach(o -> sorts.add(fromOrder(o)));
	}
	final QuerySort sort = getSort(sorts);

	return new QueryConfigurationProvider() {

		@Override
		public QueryFilter getQueryFilter() {
			return filter;
		}

		@Override
		public QuerySort getQuerySort() {
			return sort;
		}

	};
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
public void sort1() {
	// tag::sort1[]
	final PathProperty<String> PROPERTY = PathProperty.create("test", String.class);
	final PathProperty<String> ANOTHER_PROPERTY = PathProperty.create("another", String.class);

	QuerySort sort = QuerySort.asc(PROPERTY); // sort ASCENDING on given property
	sort = QuerySort.desc(PROPERTY); // sort DESCENDING on given property

	QuerySort sort2 = QuerySort.of(ANOTHER_PROPERTY, SortDirection.ASCENDING); // sort ASCENDING on given property
	sort2 = QuerySort.of(ANOTHER_PROPERTY, true); // sort ASCENDING on given property

	QuerySort.of(sort, sort2); // sort using 'sort' and 'sort2' declarations, in the given order
	// end::sort1[]
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
public void sort2() {
	// tag::sort2[]
	final PathProperty<String> PROPERTY = PathProperty.create("test", String.class);
	final PathProperty<String> ANOTHER_PROPERTY = PathProperty.create("another", String.class);

	QuerySort sort = PROPERTY.asc(); // sort ASCENDING on given property
	sort = PROPERTY.desc(); // sort DESCENDING on given property

	PROPERTY.asc().and(ANOTHER_PROPERTY.desc()); // sort ASCENDING on PROPERTY, than sort DESCENDING on
													// ANOTHER_PROPERTY
	// end::sort2[]
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
/**
 * "flatten" QuerySorts declaration into an ordered List of simple QuerySort
 * @param sorts QuerySorts
 * @return Flattened QuerySort
 */
private static List<QuerySort> flattenQuerySorts(List<QuerySort> sorts) {
	List<QuerySort> flatten = new LinkedList<>();
	if (sorts != null) {
		for (QuerySort sort : sorts) {
			if (sort instanceof CompositeQuerySort) {
				flatten.addAll(flattenQuerySorts(((CompositeQuerySort) sort).getComposition()));
			} else {
				flatten.add(sort);
			}
		}
	}
	return flatten;
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
/**
 * Constructor with initial value
 * @param sorts Build MultiSort including this sorts list as initial value
 */
public MultiSort(List<? extends QuerySort> sorts) {
	super();
	this.sorts = new LinkedList<>();
	if (sorts != null) {
		this.sorts.addAll(sorts);
	}
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public String toString() {
	StringBuilder sb = new StringBuilder();
	sb.append("MultiSort of " + sorts.size() + " sorts");
	if (!sorts.isEmpty()) {
		sb.append(" [");
		for (QuerySort sort : sorts) {
			sb.append(sort);
			sb.append(" ");
		}
		sb.append("]");
	}
	return sb.toString();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
/**
 * Add a sort to query. If any sort was present, sort will be appended in specified order
 * @param sort Sort to add
 */
@Override
public void addSort(QuerySort sort) {
	ObjectUtils.argumentNotNull(sort, "QuerySort must be not null");
	if (this.sort == null) {
		this.sort = sort;
	} else {
		this.sort = this.sort.and(sort);
	}
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
private static QuerySort fromOrder(PropertySet<?> set, QuerySortOrder order) {
	Path<?> path = getPathByName(set, order.getSorted()).orElseThrow(() -> new IllegalArgumentException(
			"No property of the set matches with sort name: " + order.getSorted()));
	SortDirection direction = (order.getDirection() != null
			&& order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING)
					? SortDirection.DESCENDING : SortDirection.ASCENDING;
	return QuerySort.of(path, direction);
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
private static QuerySort fromOrder(QuerySortOrder order, Iterable<?> properties) {
	return getPropertyPath(order.getSorted(), properties).map(path -> QuerySort.of(path,
			(order.getDirection() != null
					&& order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING)
							? SortDirection.DESCENDING : SortDirection.ASCENDING))
			.orElse(null);
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
private QuerySort fromOrder(QuerySortOrder order) {
	final SortDirection direction = (order.getDirection() != null
			&& order.getDirection() == com.vaadin.shared.data.sort.SortDirection.DESCENDING)
					? SortDirection.DESCENDING : SortDirection.ASCENDING;

	return getConfiguration().flatMap(cfg -> getSortUsingConfiguration(order.getSorted(), direction, cfg))
			.orElse(getSortFromOrder(order, direction));
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
private static QuerySort getSort(List<QuerySort> sorts) {
	if (!sorts.isEmpty()) {
		if (sorts.size() == 1) {
			return sorts.get(0);
		} else {
			return QuerySort.of(sorts);
		}
	}
	return null;
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public B sortUsing(P property, final Path<?> sortPath) {
	ObjectUtils.argumentNotNull(property, "Property must be not null");
	dataSourceBuilder.sortable(property, true);
	dataSourceBuilder.withPropertySortGenerator(property, (p, asc) -> QuerySort.of(sortPath, asc));
	return builder();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public void setFixedSort(QuerySort sort) {
	this.fixedSort = sort;
	// reset store
	resetStorePreservingFreezeState();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public void setDefaultSort(QuerySort sort) {
	this.defaultSort = sort;
	// reset store
	resetStorePreservingFreezeState();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public B fixedSort(QuerySort sort) {
	container.setFixedSort(sort);
	return builder();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public B defaultSort(QuerySort sort) {
	container.setDefaultSort(sort);
	return builder();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public B sortUsing(P property, final Path<?> sortPath) {
	ObjectUtils.argumentNotNull(property, "Property must be not null");
	dataSourceBuilder.withPropertySortGenerator(property, (p, asc) -> QuerySort.of(sortPath, asc));
	return builder();
}
 

import com.holonplatform.core.query.QuerySort; //导入依赖的package包/类
@Override
public B fixedSort(QuerySort sort) {
	dataSourceBuilder.fixedSort(sort);
	return builder();
}