Software-Entwurfsmuster

Compound-Iterator für drei Iteratoren - Implementierung

Das kartesische Produkt von drei iterierbaren Folgen lässt sich grundsätzlich mithilfe von zwei Compound-Iteratoren bilden, wobei der erste Compound-Iterator als Basisiterator des zweiten Compound-Iterators fungiert. Einfacher ist der hier vorgestellte Compound-Iterator, der drei Iteratoren verknüpft: den Basisiterator, den Subiterator und den Subsubiterator.

Abstrakte Klasse CompoundIteratorBehavior3

Ein Behavior, das einen Compound-Iterator für drei Iteratoren erzeugt, wird von der abstrakten Klasse CompoundIteratorBehavior3 abgeleitet. So ist sichergestellt, dass ein Basisiterator, ein Subiterator, ein Subsubiterator und die Funktion composeItems vorhanden sind; außerdem steht die Factory-Methode iterator zur Verfügung.

 

public abstract class CompoundIteratorBehavior3<BaseType, SubType, SubSubType, CompoundType>
implements Iterable<CompoundType>
{
    // the base iterator
    public abstract Iterator<BaseType> baseIterator();

    // the subiterator
    // x0 is the cursor object of the base iterator
    public abstract Iterator<SubType> subIterator(BaseType x0);

    // the subsubiterator
    // x0 is the cursor object of the base iterator,
    // x1 is the cursor object of the subiterator
    public abstract Iterator<SubSubType> subsubIterator(BaseType x0, SubType x1);

    // specifies the object composed of the three cursor objects x0, x1 and x2
    public abstract CompoundType composeItems(BaseType x0, SubType x1, SubSubType x2);

    // factory method that creates the compound iterator
    public Iterator<CompoundType> iterator()
    {
        return new CompoundIterator3<BaseType, SubType, SubSubType, CompoundType>(this);
    }

}

Compound-Iterator3

Es folgt die Implementierung des Compound-Iterators für drei Iteratoren

public class CompoundIterator3<BaseType, SubType, SubSubType, CompoundType>
implements Iterator<CompoundType>
{
    private CompoundIteratorBehavior3<BaseType, SubType, SubSubType, CompoundType> behavior;
    private boolean hasnext;
    private Iterator<BaseType> it0;
    private Iterator<SubType> it1;
    private Iterator<SubSubType> it2;
    private BaseType x0;
    private SubType x1;
    private CompoundType x012;

    public CompoundIterator3(CompoundIteratorBehavior3<BaseType, SubType, SubSubType, CompoundType> behavior)
    {
        this.behavior=behavior;
        hasnext=true;
        it0=behavior.baseIterator();
        x012=tryNext0();
    }

    @Override
    public boolean hasNext()
    {
        return hasnext;
    }

    @Override
    public CompoundType next()
    {
        CompoundType x=x012;
        x012=tryNext2();
        return x;
    }

    private CompoundType tryNext0()
    {
        while (it0.hasNext())
        {
            x0=it0.next();
            if (x0!=null)
            {
                it1=behavior.subIterator(x0);
                return tryNext1();
            }
        }
        hasnext=false;
        return null;
    }

    private CompoundType tryNext1()
    {
        while (it1.hasNext())
        {
            x1=it1.next();
            if (x1!=null)
            {
                it2=behavior.subsubIterator(x0, x1);
                return tryNext2();
            }
        }
        return tryNext0();
    }

    private CompoundType tryNext2()
    {
        if (it2.hasNext())
            return behavior.composeItems(x0, x1, it2.next());
        else
            return tryNext1();
    }

}

 

 

Weiter mit:  [Anwendung des Compound-Iterators für drei Iteratoren]   oder   [up]

 

H.W. Lang   mail@hwlang.de   Impressum   Datenschutz
Created: 22.02.2021   Updated: 18.02.2023
Diese Webseiten sind während meiner Lehrtätigkeit an der Hochschule Flensburg entstanden