@Override public Enumerable<Object[]> scan(final DataContext root) { final FluentIterable<Object[]> results = FluentIterable .from(rootSchema.getSubSchemaNames()) .transform( new Function<String, Object[]>() { @Override public Object[] apply(final String schemaName) { final SchemaPlus subSchema = rootSchema.getSubSchema(schemaName); return new Object[]{ CATALOG_NAME, // CATALOG_NAME subSchema.getName(), // SCHEMA_NAME null, // SCHEMA_OWNER null, // DEFAULT_CHARACTER_SET_CATALOG null, // DEFAULT_CHARACTER_SET_SCHEMA null, // DEFAULT_CHARACTER_SET_NAME null // SQL_PATH }; } } ); return Linq4j.asEnumerable(results); }
public Enumerator<T> enumerator() { //noinspection unchecked return Linq4j.enumerator(list); } };
/** Generates a map of variables and lists of values that could be assigned * to them. */ public Iterable<Map<RexNode, Comparable>> assignments() { final List<List<Comparable>> generators = variables.stream().map(RexAnalyzer::getComparables) .collect(Util.toImmutableList()); final Iterable<List<Comparable>> product = Linq4j.product(generators); //noinspection StaticPseudoFunctionalStyleMethod return Iterables.transform(product, values -> ImmutableMap.copyOf(Pair.zip(variables, values))); }
public Enumerable<Object[]> apply(Object[] lists) { final List<Enumerator<Object>> enumerators = new ArrayList<>(); for (Object list : lists) { enumerators.add(Linq4j.enumerator((List) list)); } final Enumerator<List<Object>> product = Linq4j.product(enumerators); return new AbstractEnumerable<Object[]>() { public Enumerator<Object[]> enumerator() { return Linq4j.transform(product, new Function1<List<Object>, Object[]>() { public Object[] apply(List<Object> list) { return list.toArray(); } }); } }; } };
try (Enumerator<TSource> os = enumerable.enumerator()) { if (os.moveNext()) { return Linq4j.asEnumerable(() -> new Iterator<TSource>() { return Linq4j.singletonEnumerable(value);
List<Comparable> list = (List<Comparable>) inputObject; enumerators .add(Linq4j.transform(Linq4j.enumerator(list), new Function1<Comparable, List<Comparable>>() { public List<Comparable> apply(Comparable a0) { return FlatLists.of(a0); @SuppressWarnings("unchecked") List<List<Comparable>> listList = (List<List<Comparable>>) inputObject; enumerators.add(Linq4j.enumerator(listList)); break; case MAP: @SuppressWarnings("unchecked") Map<Comparable, Comparable> map = (Map<Comparable, Comparable>) inputObject; Enumerator<Entry<Comparable, Comparable>> enumerator = Linq4j.enumerator(map.entrySet()); Enumerator<List<Comparable>> transformed = Linq4j.transform(enumerator, new Function1<Entry<Comparable, Comparable>, List<Comparable>>() { public List<Comparable> apply(Entry<Comparable, Comparable> entry) {
int leftMatchCount = 0; final TSource left = lefts.current(); final Enumerator<TInner> rights = Linq4j.iterableEnumerator(rightList); while (rights.moveNext()) { TInner right = rights.current(); Linq4j.iterableEnumerator(rightUnmatched); while (rights.moveNext()) { TInner right = rights.current(); return Linq4j.asEnumerable(result);
@SuppressWarnings("NullableProblems") @Override public Iterator<Integer> iterator() { return Linq4j.enumeratorIterator(enumerator()); }
/** Returns the cartesian product of an iterable of iterables. */ public static <T> Iterable<List<T>> product( final Iterable<? extends Iterable<T>> iterables) { return () -> { final List<Enumerator<T>> enumerators = new ArrayList<>(); for (Iterable<T> iterable : iterables) { enumerators.add(iterableEnumerator(iterable)); } return enumeratorIterator( new CartesianProductListEnumerator<>(enumerators)); }; }
CompositeEnumerable(List<Enumerable<E>> enumerableList) { enumerableEnumerator = iterableEnumerator(enumerableList); }
/** * Adapter that converts a collection into an enumerator. * * @param values Collection * @param <V> Element type * * @return Enumerator over the collection */ public static <V> Enumerator<V> enumerator(Collection<? extends V> values) { if (values instanceof List && values instanceof RandomAccess) { //noinspection unchecked return listEnumerator((List) values); } return iterableEnumerator(values); }
public Enumerable bind(DataContext dataContext) { switch (cursorFactory.style) { case ARRAY: return Linq4j.singletonEnumerable(new String[] {explanation}); case OBJECT: default: return Linq4j.singletonEnumerable(explanation); } } };
public Enumerator<T> enumerator() { return singletonEnumerator(element); } };
public Enumerable<T> bind(DataContext dataContext) { return Linq4j.emptyEnumerable(); } };
public Enumerator<T> enumerator() { //noinspection unchecked return Linq4j.enumerator(list); } };
/** Generates a map of variables and lists of values that could be assigned * to them. */ public Iterable<Map<RexNode, Comparable>> assignments() { final List<List<Comparable>> generators = variables.stream().map(RexAnalyzer::getComparables) .collect(Util.toImmutableList()); final Iterable<List<Comparable>> product = Linq4j.product(generators); //noinspection StaticPseudoFunctionalStyleMethod return Iterables.transform(product, values -> ImmutableMap.copyOf(Pair.zip(variables, values))); }
cartesians = Linq4j.product( ImmutableList.of(Linq4j.enumerator(lefts), Linq4j.enumerator(rights))); return true;
(List<Comparable>) inputObject; enumerators.add( Linq4j.transform( Linq4j.enumerator(list), FlatLists::of)); break; case LIST: @SuppressWarnings("unchecked") List<List<Comparable>> listList = (List<List<Comparable>>) inputObject; enumerators.add(Linq4j.enumerator(listList)); break; case MAP: (Map<Comparable, Comparable>) inputObject; Enumerator<Entry<Comparable, Comparable>> enumerator = Linq4j.enumerator(map.entrySet()); Enumerator<List<Comparable>> transformed = Linq4j.transform(enumerator, e -> FlatLists.of(e.getKey(), e.getValue())); enumerators.add(transformed);
public Iterator<T> iterator() { return Linq4j.enumeratorIterator(enumerator()); } }
private Cursor createCursor(ColumnMetaData.AvaticaType elementType, Iterable iterable) { final Enumerator enumerator = Linq4j.iterableEnumerator(iterable); //noinspection unchecked return !(elementType instanceof ColumnMetaData.StructType) || ((ColumnMetaData.StructType) elementType).columns.size() == 1 ? new ObjectEnumeratorCursor(enumerator) : new ArrayEnumeratorCursor(enumerator); }