SGF-402 - Implement support for proper Paging with Projections in Lucene query results.

(cherry picked from commit 9f0a07273c1241a81c5efa9e8f5f9a239e3f5ddb)
Signed-off-by: John Blum <jblum@pivotal.io>

src/main/java/org/springframework/data/gemfire/domain/EmptyPage.java

@@ -0,0 +1,62 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.domain;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.domain.Page;
+
+/**
+ * The {@link EmptyPage} class is an implementation of an empty Spring Data {@link Page}.
+ *
+ * @author John Blum
+ * @param <T> {@link Class} type of the elements in this {@link Page}.
+ * @see org.springframework.core.convert.converter.Converter
+ * @see org.springframework.data.domain.Page
+ * @since 1.1.0
+ */
+@SuppressWarnings("unused")
+public final class EmptyPage<T> extends EmptySlice<T> implements Page<T> {
+
+	@SuppressWarnings("all")
+	public static final EmptyPage<?> EMPTY_PAGE = new EmptyPage<>();
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getTotalPages() {
+		return 1;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public long getTotalElements() {
+		return 0;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public <S> Page<S> map(Converter<? super T, ? extends S> converter) {
+		return (Page<S>) EMPTY_PAGE;
+	}
+}

src/main/java/org/springframework/data/gemfire/domain/EmptySlice.java

@@ -0,0 +1,110 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.domain;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.springframework.core.convert.converter.Converter;
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.gemfire.domain.support.AbstractSliceSupport;
+
+/**
+ * The {@link EmptySlice} class is an implementation of an empty Spring Data {@link Slice}.
+ *
+ * @author John Blum
+ * @param <T> {@link Class} type of the elements in this {@link Slice}.
+ * @see org.springframework.data.domain.Pageable
+ * @see org.springframework.data.domain.Slice
+ * @see org.springframework.data.domain.Sort
+ * @see org.springframework.data.gemfire.domain.support.AbstractSliceSupport
+ * @since 1.1.0
+ */
+@SuppressWarnings("unused")
+public abstract class EmptySlice<T> extends AbstractSliceSupport<T> {
+
+	@SuppressWarnings("all")
+	public static final EmptySlice<Object> EMPTY_SLICE = new EmptySlice<Object>() { };
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasNext() {
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasPrevious() {
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public List<T> getContent() {
+		return Collections.emptyList();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getNumber() {
+		return 1;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Sort getSort() {
+		return null;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Pageable nextPageable() {
+		return null;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Pageable previousPageable() {
+		return null;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	@SuppressWarnings("unchecked")
+	public <S> Slice<S> map(Converter<? super T, ? extends S> converter) {
+		return (Slice<S>) EMPTY_SLICE;
+	}
+}

src/main/java/org/springframework/data/gemfire/domain/ListablePage.java

@@ -0,0 +1,169 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.domain;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.gemfire.domain.support.AbstractPageSupport;
+
+/**
+ * The {@link ListablePage} class is a Spring Data {@link Page} implementation wrapping a {@link List} as the content
+ * for this {@link ListablePage page}.
+ *
+ * @author John Blum
+ * @see java.util.Iterator
+ * @see java.util.List
+ * @see org.springframework.data.domain.Page
+ * @see org.springframework.data.gemfire.domain.support.AbstractPageSupport
+ * @since 1.0.0
+ */
+@SuppressWarnings("unused")
+public class ListablePage<T> extends AbstractPageSupport<T> {
+
+	/**
+	 * Factory method used to construct a new instance of {@link ListablePage} initialized with the given array,
+	 * serving as the content for this {@link Page page}.
+	 *
+	 * @param <T> {@link Class} type of the elements in the array.
+	 * @param content array of elements serving as the content for this {@link ListablePage page}.
+	 * @return a new {@link ListablePage} initialized with the given array for content.
+	 * @see java.util.Arrays#asList(Object[])
+	 * @see #ListablePage(List)
+	 */
+	@SafeVarargs
+	public static <T> ListablePage<T> newListablePage(T... content) {
+		return new ListablePage<>(Arrays.asList(content));
+	}
+
+	/**
+	 * Factory method used to construct a new instance of {@link ListablePage} initialized with the given {@link List},
+	 * serving as the content for this {@link Page page}.
+	 *
+	 * @param <T> {@link Class} type of the elements in the {@link List}.
+	 * @param content {@link List} of elements serving as the content for this {@link ListablePage page}.
+	 * @return a new {@link ListablePage} initialized with the given {@link List} for content.
+	 * @see #ListablePage(List)
+	 */
+	public static <T> ListablePage<T> newListablePage(List<T> content) {
+		return new ListablePage<>(content);
+	}
+
+	private final List<T> content;
+
+	/**
+	 * Constructs an new instance of {@link ListablePage} initialized with the given {@link List} used as the content
+	 * for this {@link ListablePage page}.
+	 *
+	 * @param content {@link List} of elements serving as the content for this {@link ListablePage page}.
+	 * Guards against {@literal null} by initializing the {@code content} to an empty {@link List}
+	 * if the given {@link List} is {@literal null}.
+	 * @see java.util.Collections#emptyList()
+	 * @see java.util.List
+	 */
+	public ListablePage(List<T> content) {
+		this.content = Optional.ofNullable(content).orElse(Collections.emptyList());
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasContent() {
+		return !getContent().isEmpty();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasNext() {
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasPrevious() {
+		return false;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public List<T> getContent() {
+		return Collections.unmodifiableList(this.content);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getNumber() {
+		return 1;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Sort getSort() {
+		return null;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public long getTotalElements() {
+		return getSize();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getTotalPages() {
+		return 1;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Iterator<T> iterator() {
+		return getContent().iterator();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public <S> Page<S> map(Function<? super T, ? extends S> converter) {
+		return newListablePage(getContent().stream().map(converter::apply).collect(Collectors.toList()));
+	}
+}

src/main/java/org/springframework/data/gemfire/domain/support/AbstractPageSupport.java

@@ -0,0 +1,65 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.domain.support;
+
+import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newUnsupportedOperationException;
+
+import java.util.function.Function;
+
+import org.springframework.data.domain.Page;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.gemfire.util.RuntimeExceptionFactory;
+
+/**
+ * The {@link AbstractPageSupport} class is an abstract Spring Data {@link Page} type supporting the implementation of
+ * application specific {@link Page} implementations.
+ *
+ * @author John Blum
+ * @param <T> {@link Class} type of the individual elements on this {@link Slice}.
+ * @see org.springframework.core.convert.converter.Converter
+ * @see org.springframework.data.domain.Page
+ * @see org.springframework.data.domain.Slice
+ * @since 1.1.0
+ */
+@SuppressWarnings("unused")
+public abstract class AbstractPageSupport<T> extends AbstractSliceSupport<T> implements Page<T> {
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public long getTotalElements() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getTotalPages() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public <S> Page<S> map(Function<? super T, ? extends S> converter) {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+}

src/main/java/org/springframework/data/gemfire/domain/support/AbstractSliceSupport.java

@@ -0,0 +1,175 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.domain.support;
+
+import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newUnsupportedOperationException;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+
+import org.springframework.data.domain.Pageable;
+import org.springframework.data.domain.Slice;
+import org.springframework.data.domain.Sort;
+import org.springframework.data.gemfire.util.RuntimeExceptionFactory;
+
+/**
+ * The {@link AbstractSliceSupport} class is an abstract Spring Data {@link Slice} type
+ * supporting the implementation of application specific {@link Slice} implementations.
+ *
+ * @author John Blum
+ * @param <T> {@link Class} type of the individual elements on this {@link Slice}.
+ * @see org.springframework.core.convert.converter.Converter
+ * @see org.springframework.data.domain.Page
+ * @see org.springframework.data.domain.Pageable
+ * @see org.springframework.data.domain.Slice
+ * @see org.springframework.data.domain.Sort
+ * @since 1.1.0
+ */
+@SuppressWarnings("unused")
+public abstract class AbstractSliceSupport<T> implements Slice<T> {
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasContent() {
+		return (getNumberOfElements() > 0);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasNext() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasPrevious() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean isFirst() {
+		return !hasPrevious();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean isLast() {
+		return !hasNext();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public List<T> getContent() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getNumber() {
+		AtomicInteger number = new AtomicInteger(1);
+
+		Optional.ofNullable(previousPageable()).ifPresent(previousPageable -> {
+			Pageable currentPageable;
+
+			do {
+				number.incrementAndGet();
+				currentPageable = previousPageable;
+				previousPageable = previousPageable.previousOrFirst();
+			}
+			while (currentPageable != previousPageable);
+		});
+
+		return number.get();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getNumberOfElements() {
+		return getContent().size();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getSize() {
+		return getNumberOfElements();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Sort getSort() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Iterator<T> iterator() {
+		return Collections.unmodifiableList(Optional.ofNullable(getContent())
+			.orElseGet(Collections::emptyList)).iterator();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public <S> Slice<S> map(Function<? super T, ? extends S> converter) {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Pageable nextPageable() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public Pageable previousPageable() {
+		throw newUnsupportedOperationException(RuntimeExceptionFactory.NOT_IMPLEMENTED);
+	}
+}

src/main/java/org/springframework/data/gemfire/search/lucene/ProjectingLuceneAccessor.java

@@ -17,10 +17,13 @@
 
 package org.springframework.data.gemfire.search.lucene;
 
+import java.util.List;
 import java.util.Optional;
+import java.util.stream.Collectors;
 
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.lucene.LuceneIndex;
+import org.apache.geode.cache.lucene.LuceneResultStruct;
 import org.springframework.beans.BeansException;
 import org.springframework.beans.factory.BeanClassLoaderAware;
 import org.springframework.beans.factory.BeanFactory;
@@ -194,4 +197,17 @@ public abstract class ProjectingLuceneAccessor extends LuceneTemplate
 	protected ProjectionFactory getProjectionFactory() {
 		return this.projectionFactory;
 	}
+
+	public <T, K, V> List<T> project(List<LuceneResultStruct<K, V>> source, Class<T> projectionType) {
+		return source.stream().map(luceneResultStruct -> project(luceneResultStruct, projectionType))
+			.collect(Collectors.toList());
+	}
+
+	public <T, K, V> T project(LuceneResultStruct<K, V> source, Class<T> projectionType) {
+		return project(source.getValue(), projectionType);
+	}
+
+	public <T> T project(Object source, Class<T> projectionType) {
+		return getProjectionFactory().createProjection(projectionType, source);
+	}
 }

src/main/java/org/springframework/data/gemfire/search/lucene/ProjectingLuceneTemplate.java

@@ -17,10 +17,9 @@
 
 package org.springframework.data.gemfire.search.lucene;
 
-import static org.springframework.data.gemfire.util.RuntimeExceptionFactory.newUnsupportedOperationException;
+import static org.springframework.data.gemfire.search.lucene.support.LucenePage.newLucenePage;
 
 import java.util.List;
-import java.util.stream.Collectors;
 
 import org.apache.geode.cache.Region;
 import org.apache.geode.cache.lucene.LuceneIndex;
@@ -92,9 +91,7 @@ public class ProjectingLuceneTemplate extends ProjectingLuceneAccessor {
 	 */
 	@Override
 	public <T> List<T> query(String query, String defaultField, int resultLimit, Class<T> projectionType) {
-		return query(query, defaultField, resultLimit).stream()
-			.map(luceneResultStruct -> getProjectionFactory().createProjection(projectionType, luceneResultStruct.getValue()))
-			.collect(Collectors.toList());
+		return project(query(query, defaultField, resultLimit), projectionType);
 	}
 
 	/**
@@ -104,7 +101,7 @@ public class ProjectingLuceneTemplate extends ProjectingLuceneAccessor {
 	public <T> Page<T> query(String query, String defaultField, int resultLimit, int pageSize,
 			Class<T> projectionType) {
 
-		throw newUnsupportedOperationException("Not Implemented");
+		return newLucenePage(this, query(query, defaultField, resultLimit, pageSize), pageSize, projectionType);
 	}
 
 	/**
@@ -112,9 +109,7 @@ public class ProjectingLuceneTemplate extends ProjectingLuceneAccessor {
 	 */
 	@Override
 	public <T> List<T> query(LuceneQueryProvider queryProvider, int resultLimit, Class<T> projectionType) {
-		return query(queryProvider, resultLimit).stream()
-			.map(luceneResultStruct -> getProjectionFactory().createProjection(projectionType, luceneResultStruct.getValue()))
-			.collect(Collectors.toList());
+		return project(query(queryProvider, resultLimit), projectionType);
 	}
 
 	/**
@@ -124,6 +119,6 @@ public class ProjectingLuceneTemplate extends ProjectingLuceneAccessor {
 	public <T> Page<T> query(LuceneQueryProvider queryProvider, int resultLimit, int pageSize,
 			Class<T> projectionType) {
 
-		throw newUnsupportedOperationException("Not Implemented");
+		return newLucenePage(this, query(queryProvider, resultLimit, pageSize), pageSize, projectionType);
 	}
 }

src/main/java/org/springframework/data/gemfire/search/lucene/support/LucenePage.java

@@ -0,0 +1,333 @@
+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+package org.springframework.data.gemfire.search.lucene.support;
+
+import static org.springframework.data.gemfire.domain.ListablePage.newListablePage;
+
+import java.util.Collections;
+import java.util.List;
+import java.util.Optional;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.function.Function;
+import java.util.stream.Collectors;
+
+import org.apache.geode.cache.lucene.LuceneResultStruct;
+import org.apache.geode.cache.lucene.PageableLuceneQueryResults;
+import org.springframework.data.domain.Page;
+import org.springframework.data.gemfire.domain.support.AbstractPageSupport;
+import org.springframework.data.gemfire.search.lucene.ProjectingLuceneAccessor;
+import org.springframework.util.Assert;
+
+/**
+ * The {@link LucenePage} class is a Spring Data {@link Page} implementation supporting Spring Data style paging
+ * of {@link PageableLuceneQueryResults} complete with Spring Data projections.
+ *
+ * @author John Blum
+ * @see java.util.List
+ * @see org.apache.geode.cache.lucene.LuceneResultStruct
+ * @see org.apache.geode.cache.lucene.PageableLuceneQueryResults
+ * @see org.springframework.data.domain.Page
+ * @see org.springframework.data.gemfire.domain.support.AbstractPageSupport
+ * @see org.springframework.data.gemfire.search.lucene.ProjectingLuceneAccessor
+ * @since 1.1.0
+ */
+public class LucenePage<T, K, V> extends AbstractPageSupport<T> {
+
+	/**
+	 * Factory method used to construct a new instance of {@link LucenePage} initialized with
+	 * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size},
+	 * and {@link Class projection type}.
+	 *
+	 * The {@link LucenePage previous page} is set to {@literal null}.
+	 *
+	 * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and  data access operations
+	 * along with projections.
+	 * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}.
+	 * @param pageSize number of elements on a {@link LucenePage}.
+	 * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct}
+	 * in the {@link PageableLuceneQueryResults Lucene query results}.
+	 * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults}
+	 * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have
+	 * a {@link PageableLuceneQueryResults#hasNext() next page}.
+	 * @see #LucenePage(ProjectingLuceneAccessor, PageableLuceneQueryResults, int, Class)
+	 */
+	public static <T, K, V> LucenePage<T, K, V> newLucenePage(ProjectingLuceneAccessor template,
+			PageableLuceneQueryResults<K, V> queryResults, int pageSize, Class<T> projectionType) {
+
+		return new LucenePage<>(template, queryResults, pageSize, projectionType);
+	}
+
+	/**
+	 * Factory method used to construct a new instance of {@link LucenePage} initialized with
+	 * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size},
+	 * {@link Class projection type} and {@link LucenePage previous page}, if one exists.
+	 *
+	 * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and  data access operations
+	 * along with projections.
+	 * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}.
+	 * @param pageSize number of elements on a {@link LucenePage}.
+	 * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct}
+	 * in the {@link PageableLuceneQueryResults Lucene query results}.
+	 * @param previousPage {@link LucenePage previous page} in the chain of {@link LucenePage pages},
+	 * if this {@link LucenePage} is not the first {@link LucenePage}.  Can be {@literal null}.
+	 * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults}
+	 * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have
+	 * a {@link PageableLuceneQueryResults#hasNext() next page}.
+	 * @see #LucenePage(ProjectingLuceneAccessor, PageableLuceneQueryResults, int, Class, LucenePage)
+	 */
+	public static <T, K, V> LucenePage<T, K, V> newLucenePage(ProjectingLuceneAccessor template,
+			PageableLuceneQueryResults<K, V> queryResults, int pageSize, Class<T> projectionType,
+			LucenePage<T, K, V> previousPage) {
+
+		return new LucenePage<>(template, queryResults, pageSize, projectionType, previousPage);
+	}
+
+	private LucenePage<T, K, V> next;
+	private LucenePage<T, K, V> previous;
+
+	private final int pageSize;
+
+	private final Class<T> projectionType;
+
+	private final List<T> content;
+
+	private final PageableLuceneQueryResults<K, V> queryResults;
+
+	private final ProjectingLuceneAccessor template;
+
+	/**
+	 * Constructs a new instance of {@link LucenePage} initialized with
+	 * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size}
+	 * and {@link Class projection type}.
+	 *
+	 * The {@link LucenePage previous page} is set to {@literal null}.
+	 *
+	 * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and  data access operations
+	 * along with projections.
+	 * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}.
+	 * @param pageSize number of elements on a {@link LucenePage}.
+	 * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct}
+	 * in the {@link PageableLuceneQueryResults Lucene query results}.
+	 * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults}
+	 * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have
+	 * a {@link PageableLuceneQueryResults#hasNext() next page}.
+	 * @see #LucenePage(ProjectingLuceneAccessor, PageableLuceneQueryResults, int, Class, LucenePage)
+	 */
+	public LucenePage(ProjectingLuceneAccessor template, PageableLuceneQueryResults<K, V> queryResults,
+			int pageSize, Class<T> projectionType) {
+
+		this(template, queryResults, pageSize, projectionType, null);
+	}
+
+	/**
+	 * Constructs a new instance of {@link LucenePage} initialized with
+	 * the given {@link PageableLuceneQueryResults Lucene query results}, {@link Integer page size},
+	 * {@link Class projection type} and {@link LucenePage previous page}, if one exists.
+	 *
+	 * @param template {@link ProjectingLuceneAccessor} used to perform Lucene queries and  data access operations
+	 * along with projections.
+	 * @param queryResults {@link PageableLuceneQueryResults} wrapped by this {@link LucenePage}.
+	 * @param pageSize number of elements on a {@link LucenePage}.
+	 * @param projectionType {@link Class} type of the projection used to view an individual {@link LuceneResultStruct}
+	 * in the {@link PageableLuceneQueryResults Lucene query results}.
+	 * @param previous {@link LucenePage previous page} in the chain of {@link LucenePage pages},
+	 * if this {@link LucenePage} is not the first {@link LucenePage}.  Can be {@literal null}.
+	 * @throws IllegalArgumentException if {@link ProjectingLuceneAccessor} or the {@link PageableLuceneQueryResults}
+	 * are {@literal null}, or the {@link PageableLuceneQueryResults} do not have
+	 * a {@link PageableLuceneQueryResults#hasNext() next page}.
+	 * @see #materialize(ProjectingLuceneAccessor, List, Class)
+	 */
+	public LucenePage(ProjectingLuceneAccessor template, PageableLuceneQueryResults<K, V> queryResults,
+			int pageSize, Class<T> projectionType, LucenePage<T, K, V> previous) {
+
+		Assert.notNull(template, "ProjectingLuceneAccessor must not be null");
+		Assert.notNull(queryResults, "PageableLuceneQueryResults must not be null");
+		Assert.isTrue(queryResults.hasNext(), "PageableLuceneQueryResults must have content");
+
+		this.template = template;
+		this.queryResults = queryResults;
+		this.pageSize = pageSize;
+		this.projectionType = projectionType;
+		this.previous = previous;
+		this.content = materialize(template, queryResults.next(), projectionType);
+	}
+
+	/**
+	 * Renders the {@link List} of {@link LuceneResultStruct} objects into projected values based on
+	 * the {@link Class projection type}.
+	 *
+	 * @param template {@link ProjectingLuceneAccessor} used to project the desired values
+	 * from the {@link List} of {@link LuceneResultStruct} objects.
+	 * @param pageOfQueryResults Lucene query results captured in the {@link List}
+	 * of {@link LuceneResultStruct} objects.
+	 * @param projectionType {@link Class} type to project the {@link LuceneResultStruct} objects as.
+	 * @return a {@link List} of projected values of the given {@link Class projection type}.
+	 * @see org.apache.geode.cache.lucene.LuceneResultStruct
+	 */
+	protected List<T> materialize(ProjectingLuceneAccessor template, List<LuceneResultStruct<K, V>> pageOfQueryResults,
+			Class<T> projectionType) {
+
+		return template.project(pageOfQueryResults, projectionType);
+	}
+
+	/**
+	 * Returns the number of elements per {@link LucenePage page}.
+	 *
+	 * @return an integer value indicating the number of elements on a {@link LucenePage page}.
+	 */
+	protected int getPageSize() {
+		return this.pageSize;
+	}
+
+	/**
+	 * Returns the {@link Class} type of the projection.
+	 *
+	 * @return a {@link Class} specifying the projection type.
+	 */
+	protected Class<T> getProjectionType() {
+		return this.projectionType;
+	}
+
+	/**
+	 * Returns the {@link PageableLuceneQueryResults Lucene query results} backing this {@link LucenePage}.
+	 *
+	 * @return a reference to the {@link PageableLuceneQueryResults} backing this {@link LucenePage}.
+	 * @see org.springframework.data.gemfire.search.lucene.support.LucenePage
+	 * @see org.apache.geode.cache.lucene.PageableLuceneQueryResults
+	 */
+	protected PageableLuceneQueryResults<K, V> getQueryResults() {
+		return this.queryResults;
+	}
+
+	/**
+	 * Returns the {@link ProjectingLuceneAccessor} used by this {@link LucenePage} to perform
+	 * Lucene data access operations and projections.
+	 *
+	 * @return the {@link ProjectingLuceneAccessor} used by this {@link LucenePage} to perform
+	 * Lucene data access operations and projections.
+	 * @see org.springframework.data.gemfire.search.lucene.ProjectingLuceneAccessor
+	 */
+	protected ProjectingLuceneAccessor getTemplate() {
+		return this.template;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasNext() {
+		return getQueryResults().hasNext();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public boolean hasPrevious() {
+		return (getPrevious() != null);
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public List<T> getContent() {
+		return Collections.unmodifiableList(this.content);
+	}
+
+	/**
+	 * Null-safe method to return the next {@link LucenePage page} in the collection of {@link Page pages}.
+	 *
+	 * @return the next {@link LucenePage page} in the collection of {@link Page pages}.
+	 * @throws IllegalStateException if no more {@link Page pages} exist beyond this {@link LucenePage page}.
+	 * @see org.springframework.data.gemfire.search.lucene.support.LucenePage
+	 * @see #getPrevious()
+	 */
+	public LucenePage<T, K, V> getNext() {
+		return Optional.ofNullable(this.next).orElseGet(() -> {
+			Assert.state(hasNext(), "No more pages");
+			this.next = newLucenePage(getTemplate(), getQueryResults(), getPageSize(), getProjectionType(), this);
+			return this.next;
+		});
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getNumber() {
+		AtomicInteger number = new AtomicInteger(1);
+
+		Optional.ofNullable(getPrevious()).ifPresent(previous -> {
+			while (previous != null) {
+				previous = previous.getPrevious();
+				number.incrementAndGet();
+			}
+		});
+
+		return number.get();
+	}
+
+	/**
+	 * Returns the previous {@link LucenePage page} in the collection of {@link Page pages}.
+	 *
+	 * @return the previous {@link LucenePage page} in the collection of {@link Page pages}
+	 * or {@literal null} if no {@link LucenePage} proceeds this {@link LucenePage page}.
+	 * @see org.springframework.data.gemfire.search.lucene.support.LucenePage
+	 * @see #getNext()
+	 */
+	public LucenePage<T, K, V> getPrevious() {
+		return this.previous;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getSize() {
+		return getPageSize();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public long getTotalElements() {
+		return getQueryResults().size();
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public int getTotalPages() {
+		long totalElements = getTotalElements();
+		int pageSize = getPageSize();
+		int totalPages = Double.valueOf(Math.floor(totalElements / pageSize)).intValue();
+		totalPages += (totalElements % pageSize != 0 ? 1 : 0);
+		return totalPages;
+	}
+
+	/**
+	 * @inheritDoc
+	 */
+	@Override
+	public <S> Page<S> map(Function<? super T, ? extends S> converter) {
+		return newListablePage(getContent().stream().map(converter::apply).collect(Collectors.toList()));
+	}
+}

src/main/java/org/springframework/data/gemfire/util/RuntimeExceptionFactory.java

@@ -31,6 +31,7 @@ import java.text.MessageFormat;
 public abstract class RuntimeExceptionFactory {
 
 	public static final String NOT_IMPLEMENTED = "Not Implemented";
+	public static final String NOT_SUPPORTED = "Operation Not Supported";
 
 	/**
 	 * Constructs and initializes an {@link IllegalArgumentException} with the given {@link String message}