How to get a generic type-safe Iterble from Iterable of other type, with a convertor? (Java 7)

Question

In our project, we use proxies-based database API (Tinkerpop Frames), so we have a lot of loops like:

    List<Link> links = new LinkedList<>();
    for (LinkModel model : obj.getLinks())
    {
        Link l = new Link(model.getLink(), model.getDescription());
        links.add(l);
    }

I would like to get rid of these for two reasons:

1. To remove boilerplate code
2. For larger lists, memory issues may arise.

Is there a nice way to get an Iterable that takes from the other one and converts using given method? What I would like to do is:

Iterable<Link> links_ = new IterableConverter<LinkModel, Link>(obj.getLinks()){
    public Link from(LinkModel m){ return new Link(m.getLink(), m.getDescription()); }
};

I guess there's something like that in Java 8. I need this for Java 7.

Answer 1

I've spent a while battling the generics, and here's the result, which seems to work fine:

import java.util.Iterator;

/**
 * An Iterable that takes from the other Iterable and converts the items using given method.
 * The primary reason is to prevent memory issues which may arise with larger lists.
 *
 *  @author Ondrej Zizka, ozizka at redhat.com
 */
public abstract class IterableConverter<TFrom, TTo> implements Iterable<TTo>, Converter<TFrom, TTo>
{
    final Iterable<TFrom> sourceIterable;

    public IterableConverter(Iterable<TFrom> sourceIterable)
    {
        this.sourceIterable = sourceIterable;
    }

    public abstract TTo from(TFrom m);


    @Override
    public Iterator<TTo> iterator()
    {
        return new IteratorBacked<TFrom, TTo>(sourceIterable.iterator(), this);
    }

    class IteratorBacked<TFromX extends TFrom, TToX extends TTo> implements Iterator<TToX> {

        private final Iterator<TFromX> backIterator;
        private final Converter<TFromX, TToX> converter;

        public IteratorBacked(Iterator<TFromX> backIterator, Converter<TFromX, TToX> converter)
        {
            this.backIterator = backIterator;
            this.converter = converter;
        }

        @Override
        public boolean hasNext()
        {
            return backIterator.hasNext();
        }


        @Override
        public TToX next()
        {
            return converter.from(backIterator.next());
        }

    }
}

interface Converter<TFromC, TToC> {
    TToC from(TFromC m);
}