// Lab23.java (C) 2009 adolfo@di-mare.com

/**
    @(#)Lab23.java 2009
    Uso de iteradores Java.

    @author Adolfo Di Mare <adolfo@di-mare.com>
*/

import java.util.Vector;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.AbstractList;

/** Muestra el uso de iteradores Java. */
public class  Lab23 {

    /** Programa principal. */
    public static void main (String []args) {
        char cV[] = {
            's','o','m','o','s','_','1','5','_','l','e','t','r','a','s'
        };
        String somos_15_letras = "somos_15_letras";
        String str = new String(cV);
        System.out.println("\n-> str.compareTo(somos_15_letras)");
        if ( 0 == str.compareTo(somos_15_letras) ) {
            System.out.println("   str y somos_15_letras son iguales");
        }
        else {
            System.out.println("   str y somos_15_letras no son iguales");
        }

        System.out.print("\n-> VL == ");
        Vector<Character> VL = new Vector<Character>();
        for ( int i=0; i<somos_15_letras.length(); ++i ) {
            VL.add( somos_15_letras.charAt(i) );
            System.out.print( "." + VL.get(i) );
        }
        System.out.print("\n-> AL == ");
        ArrayList<Character> AL = new ArrayList<Character>();
        for ( int i=0; i<cV.length; ++i ) {
            AL.add( cV[i] );
            System.out.print( "." + AL.get(i) );
        }
        System.out.println();
        System.out.print("\n-> VL.size() == " + VL.size() );
        System.out.print("\n-> AL.size() == " + AL.size() );

        Iterator<Character> iA = AL.iterator(); // mismo tipo de iterador
        Iterator<Character> iV = VL.iterator(); // -- para las 2 clases
        int diff=0; int n=0;
        if ( ! iA.hasNext() ) {
            System.out.print("\n-> iA es el culplable");
        }
        if ( ! iV.hasNext() ) {
            System.out.print("\n-> iV es el culplable");
        }
        System.out.println();
        while ( iA.hasNext() && iV.hasNext() ) {
            Character chA = iA.next();  // next se pone de primero
            Character chV = iV.next();
            if ( chA.charValue() != chV.charValue() ) {
                ++diff; // cuenta los diferentes
            }
            if ( somos_15_letras.charAt(n) != cV[n] ) {
                System.out.print( "." + somos_15_letras.charAt(n) + "." + cV[n] + "." );
            }
            ++n;
        }
        System.out.println("\n-> iA.next().charValue() != iV.next().charValue()");
        if ( diff==0 ) {
            System.out.println("   iA es igual a iV");
        }
        else {
            System.out.println("   iA no es igual a iV");
        }
        if ( iA.hasNext() ) {
            System.out.println("   iA no ha terminado");
        }
        if ( iV.hasNext() ) {
            if (VL.capacity() > VL.size() ) {
                System.out.print("   iV no ha terminado, " );
                System.out.println("pero VL[] tiene mayor capacidad: " + VL.capacity() );
            }
        }
        if ( n!=somos_15_letras.length() ) {
            System.out.println("   (" + n + ") somos_15_letras no calza con cV[]");
        }

        String RadaR = "RadaR";
        VL.clear();
        for ( int i=0; i<RadaR.length(); ++i ) {
            VL.add( RadaR.charAt(i) );
        }
        AL.clear();
        for ( int i=0; i<RadaR.length(); ++i ) {
            AL.add( RadaR.charAt(i) );
        }
        Iterator<Character> iFwd = AL.iterator();
        Alverres<Character> iBck = new Alverres<Character>( VL );
        while ( iFwd.hasNext() && iBck.hasNext() ) {
            if ( iFwd.next().charValue() != iBck.next().charValue() ) {
                System.out.println("   RadaR no es un palíndromo");
            }
        }
        if ( iFwd.hasNext() || iBck.hasNext() ) {
            System.out.println("   iFwd no terminó junto con iBck");
        }
        else {
            System.out.println("   RadaR es un palíndromo");
        }
    }

}

/** Iterador para recorrer un contenedor hacia atrás. */
class Alverres<E> implements java.util.Iterator<E> {
    /** Próximo valor que retornará {@code next()}. */
    private int m_index;
    /** Contenedor que se esta recorriendo. */
    private AbstractList<E> m_VEC;

    /** Constructor de la cVase. */
    public Alverres( AbstractList<E> VEC ) {
        m_VEC = VEC;
        m_index = VEC.size();
    }

    /** Retorna {@code true} si la iteración contiene más elementos.
        <li> En otras palabras, retorna {@code true} si el método
            {@code next()} retornara un nuevo valor en lugar de tirar una excepción.
        <li> Retorna {@code false} cuando ya la iteración terminó.
    */
    public boolean hasNext() {
        return (m_index>0);
    }

    /** Regresa el siguiente valor de la iteración.
        <li> Requiere que {@code hasNext()} sea {@code true}.
        <li> En cada invocación retorna un nuevo valor de la iteración.
    */
    public E next() {
        m_index--;
        return m_VEC.get(m_index);
    }
    /** Remueve de la lista el último valor de iteración retornado por el iterador de la lista.
        <li> Este método puede invocarse un única vez después de la invocación de {@code next()}.
        <li> El resultado del iterador es indefinido si la lista es modificada de
             cualquier forma que no sea invocando este método.
      */
    public void remove() {
        m_VEC.remove(m_index);
    }
}


// EOF: Lab23.java