code: protected <T> Page<T> loadEntities(Pager pager, EntityConvertor<BE, E, T> conversionFunction) {
          return inCommittableTx(tx -> {
              Function<BE, Pair<BE, E>> conversion =
                      (e) -> new Pair<>(e, tx.convert(e, context.entityClass));
  
              Function<Pair<BE, E>, Boolean> filter = context.configuration.getResultFilter() == null ? null :
                      (p) -> context.configuration.getResultFilter().isApplicable(p.second);
  
              Page<Pair<BE, E>> intermediate =
                      tx.<Pair<BE, E>>query(context.select().get(), pager, conversion, filter);
  
              return new TransformingPage<Pair<BE, E>, T>(intermediate,
                      (p) -> conversionFunction.convert(p.first, p.second, tx)) {
                  @Override public void close() {
                      try {
                          tx.commit();
                      } catch (CommitFailureException e) {
                          throw new IllegalStateException("Failed to commit the read operation.", e);
                      }
                      super.close();
                  }
              };
          });
      }
docs: Loads the entities given the pager and converts them using the provided conversion function to the desired type.
  
  <p>Note that the conversion function accepts both the backend entity and the converted entity because both
  of them are required anyway during the loading and thus the function can choose which one to use without any
  additional conversion cost.
  
  @param pager              the pager specifying the page of the data to load
  @param conversionFunction the conversion function to convert to the desired target type
  @param <T>                the desired target type of the elements of the returned page
  @return the page of the results as specified by the pager