public R apply(final T from) { return delegate.get(from); } }
@Override public boolean apply(final ClauseHandler clauseHandler) { return getFieldId.get(clauseHandler) != null; } };
public GroupWithAttributes get(final GenericValue gv) { return withAttributes(TO_GROUP_FUNCTION.get(gv)); } };
@Override Writer doCreate(final Index.UpdateMode mode) { return writerFactory.get(mode); }
@Override public E get(final int index) { return transformer.get(list.get(index)); }
@Override public V get(final Object key) { return transformer.get(map.get(key)); }
public V getValue() { if (value == null) { value = transformer.get(entry.getValue()); } return value; }
@Override public void visit(final T element) { list.add(function.get(element)); } });
public E next() { return decorator.get(iterator.next()); }
public R get(final T input) { R result = map.get(input); while (result == null) { map.putIfAbsent(input, function.get(input)); result = map.get(input); } return result; } };
@Override public void visit(final T element) { delegate.visit(function.get(element)); }
Query handleLessThan(final String fieldName, final T value) { return new TermRangeQuery(fieldName, null, valueFactory.get(value), true, false); }
Query handleGreaterThanEquals(final String fieldName, final T value) { return new TermRangeQuery(fieldName, valueFactory.get(value), null, true, true); }
Query handleLessThanEquals(final String fieldName, final T value) { return new TermRangeQuery(fieldName, null, valueFactory.get(value), true, true); }
Query handleGreaterThan(final String fieldName, final T value) { return new TermRangeQuery(fieldName, valueFactory.get(value), null, false, true); }
public C allValues() { return unmodifiableTransformer.get(delegate.allValues()); }
public Support get(@Nonnull final DatabaseField input) { final Function<String, String> entity = fieldTypeResolver.get(input.table()); if (entity == null) { return Support.MISSING_TABLE; } final String fieldType = entity.get(input.field()); if (fieldType == null) { return Support.MISSING_FIELD; } if (unsupportedTypes.contains(fieldType)) { return Support.UNSUPPORTED_TYPE; } return Support.SUPPORTED; } }
/** * Get the thing mapped to this key for the specified reader. * * @param one the first one * @param two the second one * @param supplier to generate the value if not already there, only called if not already cached. * @return the cached value */ public T get(@Nonnull final R one, @Nonnull final S two, final Supplier<T> supplier) { return cache.get(one).get(new Key<S, T>(two, supplier)); }
/** * Get an {@link ArrayList} of the contents of the supplied {@link EnclosedIterable} * transformed by the supplied transform function into the new type O. * * @return a mutable {@link ArrayList} containing all elements of the iterable. */ public static <I, O> List<O> toList(final EnclosedIterable<I> iterable, final Function<I, O> transformer) { final List<O> result = new ArrayList<>(iterable.size()); iterable.foreach(element -> result.add(transformer.get(element))); return result; } }