plugins/org.eclipse.sirius.services.graphql.common/src/org/eclipse/sirius/services/graphql/common/api/pagination/SiriusGraphQLPaginationDataFetcher.java - sirius/org.eclipse.sirius - Git at Google

 /*******************************************************************************
  * Copyright (c) 2019 Obeo.
  * This program and the accompanying materials
  * are made available under the terms of the Eclipse Public License 2.0
  * which accompanies this distribution, and is available at
  * https://www.eclipse.org/legal/epl-2.0/
  *
  * SPDX-License-Identifier: EPL-2.0
  *
  * Contributors:
  *    Obeo - initial API and implementation
  *******************************************************************************/
 package org.eclipse.sirius.services.graphql.common.api.pagination;

 import java.util.ArrayList;
 import java.util.List;
 import java.util.Objects;
 import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;

 import org.eclipse.sirius.services.graphql.common.api.SiriusGraphQLContext;
 import org.eclipse.sirius.services.graphql.common.api.directives.SiriusGraphQLCostDirective;
 import org.eclipse.sirius.services.graphql.common.internal.SiriusGraphQLCommonMessages;

 import graphql.schema.DataFetcher;
 import graphql.schema.DataFetchingEnvironment;
 import graphql.schema.GraphQLArgument;

 /**
  * Used to create a data fetcher supporting the pagination.
  *
  * @author sbegaudeau
  */
 public final class SiriusGraphQLPaginationDataFetcher {

     /**
      * The constructor.
      */
     private SiriusGraphQLPaginationDataFetcher() {
         // Prevent instantiation
     }

     /**
      * Creates the data fetcher used to return the paginated result.
      *
      * @param callback
      *            The function used to compute the edges
      * @param cursorComputer
      *            The function used to compute the cursor for each edge
      * @param <T>
      *            The type of the edges to return
      * @return The data fetcher used to return the paginated result.
      */
     public static <T> DataFetcher<SiriusGraphQLConnection> build(Function<DataFetchingEnvironment, List<T>> callback, Function<T, String> cursorComputer) {
         return environment -> {
             Integer first = SiriusGraphQLPaginationDataFetcher.getFirst(environment);
             Integer last = SiriusGraphQLPaginationDataFetcher.getLast(environment);
             String after = SiriusGraphQLPaginationDataFetcher.getAfter(environment);
             String before = SiriusGraphQLPaginationDataFetcher.getBefore(environment);

             SiriusGraphQLPaginationDataFetcher.assertArguments(environment);

             int cost = SiriusGraphQLPaginationDataFetcher.getCost(environment);
             // @formatter:off
             Optional.ofNullable(environment.getContext())
                 .filter(SiriusGraphQLContext.class::isInstance)
                 .map(SiriusGraphQLContext.class::cast)
                 .ifPresent(context -> context.add(cost));
             // @formatter:on

             List<T> allEdges = callback.apply(environment);
             List<T> edgesToReturn = SiriusGraphQLPaginationDataFetcher.getEdgesToReturn(allEdges, before, after, first, last, cursorComputer);

             // @formatter:off
             List<SiriusGraphQLEdge> edges = edgesToReturn.stream()
                     .map(edge -> new SiriusGraphQLEdge(edge, cursorComputer.apply(edge)))
                     .collect(Collectors.toList());
             // @formatter:on

             int totalCount = allEdges.size();
             boolean hasPreviousPage = SiriusGraphQLPaginationDataFetcher.hasPreviousPage(allEdges, edgesToReturn);
             boolean hasNextPage = SiriusGraphQLPaginationDataFetcher.hasNextPage(allEdges, edgesToReturn);
             SiriusGraphQLPageInfo pageInfo = new SiriusGraphQLPageInfo(hasPreviousPage, hasNextPage);
             return new SiriusGraphQLConnection(totalCount, edges, pageInfo);
         };
     }

     /**
      * Asserts the validity of the arguments retrieved.
      *
      * @param environment
      *            The data fetching environment
      */
     private static void assertArguments(DataFetchingEnvironment environment) {
         Integer first = SiriusGraphQLPaginationDataFetcher.getFirst(environment);
         Integer last = SiriusGraphQLPaginationDataFetcher.getLast(environment);

         // Both after and before can be null but it has to be a specified value
         boolean hasFowardPaginationArguments = first != null && environment.containsArgument(SiriusGraphQLPaginationArguments.AFTER_ARG);
         boolean hasBackwardPaginationArguments = last != null && environment.containsArgument(SiriusGraphQLPaginationArguments.BEFORE_ARG);

         if (!hasFowardPaginationArguments && !hasBackwardPaginationArguments) {
             throw new IllegalArgumentException(SiriusGraphQLCommonMessages.SiriusGraphQLPaginationDataFetcher_invalidArguments);
         }
     }

     /**
      * Returns the value of the first argument.
      *
      * @param environment
      *            The data fetching environment.
      * @return The value of the first argument
      */
     private static Integer getFirst(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.FIRST_ARG))
                 .filter(Integer.class::isInstance)
                 .map(Integer.class::cast)
                 .orElse(null);
         // @formatter:on
     }

     /**
      * Returns the value of the last argument.
      *
      * @param environment
      *            The data fetching environment.
      * @return The value of the last argument
      */
     private static Integer getLast(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.LAST_ARG))
                 .filter(Integer.class::isInstance)
                 .map(Integer.class::cast)
                 .orElse(null);
         // @formatter:on
     }

     /**
      * Returns the value of the after argument.
      *
      * @param environment
      *            The data fetching environment.
      * @return The value of the after argument
      */
     private static String getAfter(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.AFTER_ARG))
                 .filter(String.class::isInstance)
                 .map(String.class::cast)
                 .orElse(null);
         // @formatter:on
     }

     /**
      * Returns the value of the before argument.
      *
      * @param environment
      *            The data fetching environment.
      * @return The value of the before argument
      */
     private static String getBefore(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.BEFORE_ARG))
                 .filter(String.class::isInstance)
                 .map(String.class::cast)
                 .orElse(null);
         // @formatter:on
     }

     /**
      * Returns the complexity of the field.
      *
      * @param environment
      *            The data fetching environment
      * @return The complexity of the field
      */
     private static int getComplexity(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getFieldDefinition().getDirective(SiriusGraphQLCostDirective.COST))
                 .map(directive -> directive.getArgument(SiriusGraphQLCostDirective.COMPLEXITY_ARG))
                 .map(GraphQLArgument::getDefaultValue)
                 .filter(Integer.class::isInstance)
                 .map(Integer.class::cast)
                 .orElse(Integer.valueOf(0))
                 .intValue();
         // @formatter:on
     }

     /**
      * Returns the multipliers of the field.
      *
      * @param environment
      *            The data fetching environment
      * @return The multipliers of the field
      */
     private static List<String> getMultipliers(DataFetchingEnvironment environment) {
         // @formatter:off
         return Optional.ofNullable(environment.getFieldDefinition().getDirective(SiriusGraphQLCostDirective.COST))
                 .map(directive -> directive.getArgument(SiriusGraphQLCostDirective.MULTIPLIERS_ARG))
                 .map(GraphQLArgument::getDefaultValue)
                 .map(value -> {
                     if (value instanceof List<?>) {
                         return ((List<?>) value).stream()
                                     .filter(String.class::isInstance)
                                     .map(String.class::cast)
                                     .collect(Collectors.toList());
                     }
                     return new ArrayList<String>();
                 })
                 .orElseGet(ArrayList::new);
         // @formatter:on
     }

     /**
      * Returns the cost of fetching the elements requested.
      *
      * @param environment
      *            The data fetching environment
      * @return The cost of fetching the elements requested
      */
     private static int getCost(DataFetchingEnvironment environment) {
         int complexity = SiriusGraphQLPaginationDataFetcher.getComplexity(environment);
         List<String> multipliers = SiriusGraphQLPaginationDataFetcher.getMultipliers(environment);

         int cost = 0;
         for (String multiplier : multipliers) {
             // @formatter:off
             int value = Optional.ofNullable(environment.getArgument(multiplier))
                     .filter(Integer.class::isInstance)
                     .map(Integer.class::cast)
                     .orElse(Integer.valueOf(0))
                     .intValue();
             // @formatter:on

             cost = cost + (value * complexity);
         }

         return cost;
     }

     /**
      * Indicates if there is a previous page.
      *
      * @param edges
      *            The whole list of edges to consider
      * @param edgesToReturn
      *            The list of edges to return
      * @param <T>
      *            The type of the edge
      * @return <code>true</code> if there is a previous page, <code>false</code> otherwise
      */
     private static <T> boolean hasPreviousPage(List<T> edges, List<T> edgesToReturn) {
         return edges.size() > 0 && (edgesToReturn.isEmpty() || edges.indexOf(edgesToReturn.get(0)) > 0);
     }

     /**
      * Indicates if there is a next page.
      *
      * @param edges
      *            The whole list of edges to consider
      * @param edgesToReturn
      *            The list of edges to return
      * @param <T>
      *            The type of the edge
      * @return <code>true</code> if there is a next page, <code>false</code> otherwise
      */
     private static <T> boolean hasNextPage(List<T> edges, List<T> edgesToReturn) {
         return edges.size() > 0 && (!edgesToReturn.isEmpty() && edges.indexOf(edgesToReturn.get(edgesToReturn.size() - 1)) < edges.size() - 1);
     }

     /**
      * Computes the edges to return for the given pagination arguments. See
      * https://facebook.github.io/relay/graphql/connections.htm#sec-Pagination-algorithm
      *
      * @param allEdges
      *            All the edges which can be returned
      * @param before
      *            The before cursor
      * @param after
      *            The after cursor
      * @param first
      *            The number of edges to return for the forward pagination
      * @param last
      *            The number of edges to return for the backward pagination
      * @param cursorComputer
      *            The function used to compute the cursor
      * @param <T>
      *            The type of the edge
      * @return The sliced edges
      */
     private static <T> List<T> getEdgesToReturn(List<T> allEdges, String before, String after, Integer first, Integer last, Function<T, String> cursorComputer) {
         List<T> edges = SiriusGraphQLPaginationDataFetcher.applyCursorsToEdges(allEdges, before, after, cursorComputer);
         if (Objects.nonNull(first) && first.intValue() > 0 && edges.size() > first.intValue()) {
             edges = edges.subList(0, first.intValue());
         }
         if (Objects.nonNull(last) && last.intValue() > 0 && edges.size() > last.intValue()) {
             edges = edges.subList(edges.size() - last.intValue(), edges.size());
         }
         return edges;
     }

     /**
      * Apply the cursor to the given edges. See
      * https://facebook.github.io/relay/graphql/connections.htm#ApplyCursorsToEdges()
      *
      * @param allEdges
      *            The list of the edges
      * @param before
      *            The before cursor
      * @param after
      *            The after cursor
      * @param cursorComputer
      *            The function used to compute the cursor
      * @param <T>
      *            The type of the edge
      * @return The sliced list of edges
      */
     private static <T> List<T> applyCursorsToEdges(List<T> allEdges, String before, String after, Function<T, String> cursorComputer) {
         List<T> edges = allEdges;
         if (Objects.nonNull(after) && !after.isEmpty()) {
             // @formatter:off
             Optional<T> optionalAfterEdge = edges.stream()
                     .filter(anEdge -> after.equals(cursorComputer.apply(anEdge)))
                     .findFirst();
             if (optionalAfterEdge.isPresent()) {
                 T afterEdge = optionalAfterEdge.get();
                 int afterEdgeIndex = edges.indexOf(afterEdge);
                 edges = edges.subList(afterEdgeIndex + 1, edges.size());
             }
             // @formatter:on
         } else if (Objects.nonNull(before) && !before.isEmpty()) {
             // @formatter:off
             Optional<T> optionalBeforeEdge = edges.stream()
                     .filter(anEdge -> before.equals(cursorComputer.apply(anEdge)))
                     .findFirst();
             if (optionalBeforeEdge.isPresent()) {
                 T beforeEdge = optionalBeforeEdge.get();
                 int beforeEdgeIndex = edges.indexOf(beforeEdge);
                 edges = edges.subList(0, beforeEdgeIndex);
             }
             // @formatter:on
         }
         return edges;
     }
 }
	/*******************************************************************************
	* Copyright (c) 2019 Obeo.
	* This program and the accompanying materials
	* are made available under the terms of the Eclipse Public License 2.0
	* which accompanies this distribution, and is available at
	* https://www.eclipse.org/legal/epl-2.0/
	*
	* SPDX-License-Identifier: EPL-2.0
	*
	* Contributors:
	* Obeo - initial API and implementation
	*******************************************************************************/
	package org.eclipse.sirius.services.graphql.common.api.pagination;

	import java.util.ArrayList;
	import java.util.List;
	import java.util.Objects;
	import java.util.Optional;
	import java.util.function.Function;
	import java.util.stream.Collectors;

	import org.eclipse.sirius.services.graphql.common.api.SiriusGraphQLContext;
	import org.eclipse.sirius.services.graphql.common.api.directives.SiriusGraphQLCostDirective;
	import org.eclipse.sirius.services.graphql.common.internal.SiriusGraphQLCommonMessages;

	import graphql.schema.DataFetcher;
	import graphql.schema.DataFetchingEnvironment;
	import graphql.schema.GraphQLArgument;

	/**
	* Used to create a data fetcher supporting the pagination.
	*
	* @author sbegaudeau
	*/
	public final class SiriusGraphQLPaginationDataFetcher {

	/**
	* The constructor.
	*/
	private SiriusGraphQLPaginationDataFetcher() {
	// Prevent instantiation
	}

	/**
	* Creates the data fetcher used to return the paginated result.
	*
	* @param callback
	* The function used to compute the edges
	* @param cursorComputer
	* The function used to compute the cursor for each edge
	* @param <T>
	* The type of the edges to return
	* @return The data fetcher used to return the paginated result.
	*/
	public static <T> DataFetcher<SiriusGraphQLConnection> build(Function<DataFetchingEnvironment, List<T>> callback, Function<T, String> cursorComputer) {
	return environment -> {
	Integer first = SiriusGraphQLPaginationDataFetcher.getFirst(environment);
	Integer last = SiriusGraphQLPaginationDataFetcher.getLast(environment);
	String after = SiriusGraphQLPaginationDataFetcher.getAfter(environment);
	String before = SiriusGraphQLPaginationDataFetcher.getBefore(environment);

	SiriusGraphQLPaginationDataFetcher.assertArguments(environment);

	int cost = SiriusGraphQLPaginationDataFetcher.getCost(environment);
	// @formatter:off
	Optional.ofNullable(environment.getContext())
	.filter(SiriusGraphQLContext.class::isInstance)
	.map(SiriusGraphQLContext.class::cast)
	.ifPresent(context -> context.add(cost));
	// @formatter:on

	List<T> allEdges = callback.apply(environment);
	List<T> edgesToReturn = SiriusGraphQLPaginationDataFetcher.getEdgesToReturn(allEdges, before, after, first, last, cursorComputer);

	// @formatter:off
	List<SiriusGraphQLEdge> edges = edgesToReturn.stream()
	.map(edge -> new SiriusGraphQLEdge(edge, cursorComputer.apply(edge)))
	.collect(Collectors.toList());
	// @formatter:on

	int totalCount = allEdges.size();
	boolean hasPreviousPage = SiriusGraphQLPaginationDataFetcher.hasPreviousPage(allEdges, edgesToReturn);
	boolean hasNextPage = SiriusGraphQLPaginationDataFetcher.hasNextPage(allEdges, edgesToReturn);
	SiriusGraphQLPageInfo pageInfo = new SiriusGraphQLPageInfo(hasPreviousPage, hasNextPage);
	return new SiriusGraphQLConnection(totalCount, edges, pageInfo);
	};
	}

	/**
	* Asserts the validity of the arguments retrieved.
	*
	* @param environment
	* The data fetching environment
	*/
	private static void assertArguments(DataFetchingEnvironment environment) {
	Integer first = SiriusGraphQLPaginationDataFetcher.getFirst(environment);
	Integer last = SiriusGraphQLPaginationDataFetcher.getLast(environment);

	// Both after and before can be null but it has to be a specified value
	boolean hasFowardPaginationArguments = first != null && environment.containsArgument(SiriusGraphQLPaginationArguments.AFTER_ARG);
	boolean hasBackwardPaginationArguments = last != null && environment.containsArgument(SiriusGraphQLPaginationArguments.BEFORE_ARG);

	if (!hasFowardPaginationArguments && !hasBackwardPaginationArguments) {
	throw new IllegalArgumentException(SiriusGraphQLCommonMessages.SiriusGraphQLPaginationDataFetcher_invalidArguments);
	}
	}

	/**
	* Returns the value of the first argument.
	*
	* @param environment
	* The data fetching environment.
	* @return The value of the first argument
	*/
	private static Integer getFirst(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.FIRST_ARG))
	.filter(Integer.class::isInstance)
	.map(Integer.class::cast)
	.orElse(null);
	// @formatter:on
	}

	/**
	* Returns the value of the last argument.
	*
	* @param environment
	* The data fetching environment.
	* @return The value of the last argument
	*/
	private static Integer getLast(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.LAST_ARG))
	.filter(Integer.class::isInstance)
	.map(Integer.class::cast)
	.orElse(null);
	// @formatter:on
	}

	/**
	* Returns the value of the after argument.
	*
	* @param environment
	* The data fetching environment.
	* @return The value of the after argument
	*/
	private static String getAfter(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.AFTER_ARG))
	.filter(String.class::isInstance)
	.map(String.class::cast)
	.orElse(null);
	// @formatter:on
	}

	/**
	* Returns the value of the before argument.
	*
	* @param environment
	* The data fetching environment.
	* @return The value of the before argument
	*/
	private static String getBefore(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getArgument(SiriusGraphQLPaginationArguments.BEFORE_ARG))
	.filter(String.class::isInstance)
	.map(String.class::cast)
	.orElse(null);
	// @formatter:on
	}

	/**
	* Returns the complexity of the field.
	*
	* @param environment
	* The data fetching environment
	* @return The complexity of the field
	*/
	private static int getComplexity(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getFieldDefinition().getDirective(SiriusGraphQLCostDirective.COST))
	.map(directive -> directive.getArgument(SiriusGraphQLCostDirective.COMPLEXITY_ARG))
	.map(GraphQLArgument::getDefaultValue)
	.filter(Integer.class::isInstance)
	.map(Integer.class::cast)
	.orElse(Integer.valueOf(0))
	.intValue();
	// @formatter:on
	}

	/**
	* Returns the multipliers of the field.
	*
	* @param environment
	* The data fetching environment
	* @return The multipliers of the field
	*/
	private static List<String> getMultipliers(DataFetchingEnvironment environment) {
	// @formatter:off
	return Optional.ofNullable(environment.getFieldDefinition().getDirective(SiriusGraphQLCostDirective.COST))
	.map(directive -> directive.getArgument(SiriusGraphQLCostDirective.MULTIPLIERS_ARG))
	.map(GraphQLArgument::getDefaultValue)
	.map(value -> {
	if (value instanceof List<?>) {
	return ((List<?>) value).stream()
	.filter(String.class::isInstance)
	.map(String.class::cast)
	.collect(Collectors.toList());
	}
	return new ArrayList<String>();
	})
	.orElseGet(ArrayList::new);
	// @formatter:on
	}

	/**
	* Returns the cost of fetching the elements requested.
	*
	* @param environment
	* The data fetching environment
	* @return The cost of fetching the elements requested
	*/
	private static int getCost(DataFetchingEnvironment environment) {
	int complexity = SiriusGraphQLPaginationDataFetcher.getComplexity(environment);
	List<String> multipliers = SiriusGraphQLPaginationDataFetcher.getMultipliers(environment);

	int cost = 0;
	for (String multiplier : multipliers) {
	// @formatter:off
	int value = Optional.ofNullable(environment.getArgument(multiplier))
	.filter(Integer.class::isInstance)
	.map(Integer.class::cast)
	.orElse(Integer.valueOf(0))
	.intValue();
	// @formatter:on

	cost = cost + (value * complexity);
	}

	return cost;
	}

	/**
	* Indicates if there is a previous page.
	*
	* @param edges
	* The whole list of edges to consider
	* @param edgesToReturn
	* The list of edges to return
	* @param <T>
	* The type of the edge
	* @return <code>true</code> if there is a previous page, <code>false</code> otherwise
	*/
	private static <T> boolean hasPreviousPage(List<T> edges, List<T> edgesToReturn) {
	return edges.size() > 0 && (edgesToReturn.isEmpty() \|\| edges.indexOf(edgesToReturn.get(0)) > 0);
	}

	/**
	* Indicates if there is a next page.
	*
	* @param edges
	* The whole list of edges to consider
	* @param edgesToReturn
	* The list of edges to return
	* @param <T>
	* The type of the edge
	* @return <code>true</code> if there is a next page, <code>false</code> otherwise
	*/
	private static <T> boolean hasNextPage(List<T> edges, List<T> edgesToReturn) {
	return edges.size() > 0 && (!edgesToReturn.isEmpty() && edges.indexOf(edgesToReturn.get(edgesToReturn.size() - 1)) < edges.size() - 1);
	}

	/**
	* Computes the edges to return for the given pagination arguments. See
	* https://facebook.github.io/relay/graphql/connections.htm#sec-Pagination-algorithm
	*
	* @param allEdges
	* All the edges which can be returned
	* @param before
	* The before cursor
	* @param after
	* The after cursor
	* @param first
	* The number of edges to return for the forward pagination
	* @param last
	* The number of edges to return for the backward pagination
	* @param cursorComputer
	* The function used to compute the cursor
	* @param <T>
	* The type of the edge
	* @return The sliced edges
	*/
	private static <T> List<T> getEdgesToReturn(List<T> allEdges, String before, String after, Integer first, Integer last, Function<T, String> cursorComputer) {
	List<T> edges = SiriusGraphQLPaginationDataFetcher.applyCursorsToEdges(allEdges, before, after, cursorComputer);
	if (Objects.nonNull(first) && first.intValue() > 0 && edges.size() > first.intValue()) {
	edges = edges.subList(0, first.intValue());
	}
	if (Objects.nonNull(last) && last.intValue() > 0 && edges.size() > last.intValue()) {
	edges = edges.subList(edges.size() - last.intValue(), edges.size());
	}
	return edges;
	}

	/**
	* Apply the cursor to the given edges. See
	* https://facebook.github.io/relay/graphql/connections.htm#ApplyCursorsToEdges()
	*
	* @param allEdges
	* The list of the edges
	* @param before
	* The before cursor
	* @param after
	* The after cursor
	* @param cursorComputer
	* The function used to compute the cursor
	* @param <T>
	* The type of the edge
	* @return The sliced list of edges
	*/
	private static <T> List<T> applyCursorsToEdges(List<T> allEdges, String before, String after, Function<T, String> cursorComputer) {
	List<T> edges = allEdges;
	if (Objects.nonNull(after) && !after.isEmpty()) {
	// @formatter:off
	Optional<T> optionalAfterEdge = edges.stream()
	.filter(anEdge -> after.equals(cursorComputer.apply(anEdge)))
	.findFirst();
	if (optionalAfterEdge.isPresent()) {
	T afterEdge = optionalAfterEdge.get();
	int afterEdgeIndex = edges.indexOf(afterEdge);
	edges = edges.subList(afterEdgeIndex + 1, edges.size());
	}
	// @formatter:on
	} else if (Objects.nonNull(before) && !before.isEmpty()) {
	// @formatter:off
	Optional<T> optionalBeforeEdge = edges.stream()
	.filter(anEdge -> before.equals(cursorComputer.apply(anEdge)))
	.findFirst();
	if (optionalBeforeEdge.isPresent()) {
	T beforeEdge = optionalBeforeEdge.get();
	int beforeEdgeIndex = edges.indexOf(beforeEdge);
	edges = edges.subList(0, beforeEdgeIndex);
	}
	// @formatter:on
	}
	return edges;
	}
	}