Iterador sobre una colección. Más...

#include <iterJava.h>

Métodos públicos
	iterJava ()
	Constructor por defecto. Más...

	iterJava (Iter first, Iter end)
	Constructor para recorrer desde `first` y hasta antes de `end`. Más...

	iterJava (const iterJava &o)
	Constructor de copia. Más...

	~iterJava ()
	Destructor. Más...

iterJava &	operator= (const iterJava &o)
	Copiador. Más...

bool	hasNext () const
	Retorna `true` si la iteración tiene más elementos. Más...

std::iterator_traits< Iter > ::reference	next ()
	Retorna el siguiente element de la iteración. Más...

std::iterator_traits< Iter > ::reference	current () const
	Retorna el valor que la última invocación de `next()` retornó. Más...

	operator Iter () const
	Convierte el valor en un iterador sobre la colección que se recorre. Más...

void	set (Iter first, Iter end)
	Establece que la iteración se hará desde `first` hasta antes de `end`. Más...

template<typename C >
void	set (C &CCC)
	Establece que la iteración se hará sobre `C`. Más...

template<typename C >
void	set (const C &CCC)
	Establece que la iteración se hará sobre `C` ( versión `const` ). Más...

void	setReverse ()
	Establece que el iterador irá hacia atrás, en reversa. Más...

bool	isForward () const
	Retorna `true` si la iteración es natural, desde el primero al útlimo. Más...

bool	isReverse () const
	Retorna `true` si la iteración va hacia atrás, en reversa. Más...

void	setBackward ()
	Establece que el iterador irá hacia atrás, en reversa. Más...

bool	isBackward () const
	Retorna `true` si la iteración va hacia atrás, en reversa. Más...

Atributos protegidos
Iter	itPrev
	Recuerda el último valor retornado. Más...

Iter	itNext
	Siguiente valor por retornar. Más...

Iter	itEnd
	Pasado del último valor. Más...

bool	isFwd
	`"false"` si es un `reverse_iterator`. Más...

Amigas
bool	operator== (const iterJava< Iter > &l, const iterJava< Iter > &r)
	( l == r ) ? Más...

bool	operator!= (const iterJava< Iter > &l, const iterJava< Iter > &r)
	( l != r ) ? Más...

Descripción detallada

template<typename Iter>
class iterJava< Iter >

Iterador sobre una colección.

Los iteradores difieren de las enumeraciones en 2 formas:

Los iteradores permiten que el invocador borre valores de la colección que se recorre durante la iteración, con semántica bien definida.
Los nombres de los métodos han sido mejorados.
En Java, la clase Iterator toma el lugar de Enumeration en el marco de trabajo de colecciones (Java collections framework).

    {{  // test::example()
        std::list<long> Lfwd, Lbck, L;
        assertTrue( Lfwd.empty() && L.empty() );
        L = makeList_long( "( 1 2 3 4 5 )" );
        iterJava< std::list<long>::iterator > itFwd( L.begin(), L.end() );
        iterJava< std::list<long>::iterator > itBck( L.begin(), L.end() );
        itBck.setReverse();
        while ( itFwd.hasNext() && itBck.hasNext() ) {
            Lfwd.push_back( itFwd.next() );
            Lbck.push_back( itBck.next() );
        }
        assertTrue( Lfwd == makeList_long( "( 1 2 3 4 5 )" ) );
        assertTrue( Lbck == makeList_long( "( 5 4 3 2 1 )" ) );
    }}

Ver también: test_iterJava::test_example()

Tanto los iteradores const como no-const trabajan como se espera.

    {{  // test::const_example()
        #define const_error
        #undef  const_error
        std::list<long> Lcp, L;
        assertTrue( Lcp.empty() );
        L = makeList_long( "( 1 2 3 4 5 )" );
        iterJava< std::list<long>::const_iterator > iter( L.begin(),L.end() );
        while ( iter.hasNext() ) {
            Lcp.push_back( iter.next() );
            #ifdef const_error
                L.erase(iter); // forbidden for const_iterator
            #endif
        }
        assertTrue( L == Lcp );
        iterJava< std::list<long>::const_iterator > IT = iter;
        assertTrue( IT == iter && !( IT.hasNext() ) && !( IT != iter ) );
        #undef  const_error
    }}

Ver también: test_iterJava::test_const_example()

En vectores la operación remove() no puede ser useda.

    {{  // test::examplePtr()
        #define dim(V) ( sizeof(V)/sizeof(*V) )
        std::list<long> L;
        int VEC[] = { 1, 2, 3, 4, 5 };
        iterJava< int* > iter( VEC, VEC+dim(VEC) );
        while ( iter.hasNext() ) {
            L.push_back( iter.next() );
        }
        assertTrue( L == makeList_long( "( 1 2 3 4 5 )" ) );
    }}

Ver también: test_iterJava::test_examplePtr()

Definición en la línea 23 del archivo iterJava.h.

Documentación del constructor y destructor

template<typename Iter>

iterJava< Iter >::iterJava ( )

inline

Constructor por defecto.

Definición en la línea 30 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::iterJava	(	Iter	first,
		Iter	end
	)

inline

Constructor para recorrer desde first y hasta antes de end.

Definición en la línea 32 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::iterJava ( const iterJava< Iter > & o )

inline

Constructor de copia.

Definición en la línea 34 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::~iterJava ( )

inline

Destructor.

Definición en la línea 37 del archivo iterJava.h.

Documentación de las funciones miembro

template<typename Iter>

iterJava< Iter >::operator= ( const iterJava< Iter > & o )

inline

Copiador.

    {{  // test::assign()
        std::list<long> L, Lcp;
        L = makeList_long( "( 1 2 3 4 5 )" );
        iterJava< std::list<long>::const_iterator > iter123;
        iterJava< std::list<long>::const_iterator > iter45;
        iter123.set( L.begin(), L.end() ); // full range
        int i=1;
        while ( i<=3 ) {
            assertTrue( i == iter123.next() );
            Lcp.push_back( i );
            ++i;
        }
        iter45 = iter123; // iter45 <==> iter123
        while ( i<=5 ) {
            assertTrue( i == iter45.next() );
            Lcp.push_back( i );
            ++i;
        }
        assertTrue( Lcp == makeList_long( "( 1 2 3 4 5 )" ) );
    }}

Ver también: test_iterJava::test_assign()

Definición en la línea 38 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::hasNext ( ) const

inline

Retorna true si la iteración tiene más elementos.

   (En otras palabras, retorna \c true si \c next() retornaría un elemento
   en lugar de fallar.)

Devuelve: true si la iteración tiene más elementos.

Definición en la línea 44 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::next ( )

inline

Retorna el siguiente element de la iteración.

   Al invocar este método repetidamente hasta que el método \c hasNext() retorne
   \c false retornará cada elemento de la collección que se recorre exactamente
   una vez.

Devuelve: El siguiente element de la iteración.

    {{  // test::next()
        std::list<long> L = makeList_long( "( 1 2 3 4 5 )" );
        iterJava< std::list<long>::iterator > iter( L.begin(), L.end() );
        int  trngl = 3;
        while ( iter.hasNext() ) {
            switch (trngl++ % 3) {
                case 0: { // reference
                    long & l = iter.next(); l++;
                    break;
                }
                case 1: { // pointer
                    long * p = & iter.next(); (*p)++;
                    break;
                }
                case 2: { // direct
                    iter.next()++;
                    break;
                }
            }
        }
        assertTrue( L == makeList_long( "( 2 3 4 5 6 )" ) );
    }}

Ver también: test_iterJava::test_next()

Definición en la línea 48 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::current ( ) const

inline

Retorna el valor que la última invocación de next() retornó.

   - Invocar este método después de que el valor del iterador iterador fue establecido
     pero antes de la primera invocación de \c next() es aun error.

Devuelve: El valor que la última invocación de next() retornó.

Definición en la línea 57 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::operator Iter ( ) const

inline

Convierte el valor en un iterador sobre la colección que se recorre.

Este convertidor es útil para eliminar valores de la colección que se recorre el último valor que next() retornó.
La conversión funciona para operaciones const y para las que no son const.

Devuelve: El valor que la última invocación de next() retornó.

    {{  // test::erase()
        std::list<long> L = makeList_long( "( 1 2 3 4 5 )" );
        iterJava< std::list<long>::iterator > iter( L.begin(), L.end() );
        int i = 0;
        while ( iter.hasNext() ) {
            assertTrue( ! L.empty() );
            long *pL = & iter.next(); i++;
            assertTrue( i == *pL );
            L.erase( iter ); // L.erase( iter.current() );
        }
        assertTrue( L.empty() );
    }}

Ver también: test_iterJava::test_erase()

Definición en la línea 58 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::set	(	Iter	first,
		Iter	end
	)

inline

Establece que la iteración se hará desde first hasta antes de end.

Definición en la línea 60 del archivo iterJava.h.

template<typename Iter>

template<typename C >

iterJava< Iter >::set ( C & CCC )

inline

Establece que la iteración se hará sobre C.

Definición en la línea 62 del archivo iterJava.h.

template<typename Iter>

template<typename C >

iterJava< Iter >::set ( const C & CCC )

inline

Establece que la iteración se hará sobre C ( versión const ).

    {{  // test::set_CCC()
        std::list<long> L1 = makeList_long( "( 1 2 3 4 5 )" );
        std::list<long> L2 = makeList_long( "( 6 7 8 9 )" );
        iterJava< std::list<long>::iterator > iter( L1.begin(), L1.end() );
        int i = 0;
        while ( iter.hasNext() ) { // L1
            i++; assertTrue( i == iter.next() );
            L1.erase( iter );
        }
        iter.set( L2 );
        while ( iter.hasNext() ) { // L2
            i++; assertTrue( i == iter.next() );
        }
        assertTrue( L1.empty() );
    }}

Ver también: test_iterJava::test_set_CCC()

Definición en la línea 64 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::setReverse ( )

inline

Establece que el iterador irá hacia atrás, en reversa.

Precondición: No debe invocarse el método next() antes de usar setReverse().

Ver también: isPalindrome();

    {{  // test::palindrome()
        std::list<long> L = makeList_long( "( 1 2 3 2 1 )" );
        typedef std::list<long>::const_iterator IterFwd;
        typedef std::reverse_iterator<IterFwd> IterBck;
        iterJava< IterFwd > itFwd( L.begin(),  L.end()  );
        iterJava< IterBck > itBck( L.rbegin(), L.rend() );
        while ( itFwd.hasNext() && itBck.hasNext() ) {
            if ( itFwd.next() != itBck.next() ) {
                assertTrue( "palindrome error" &&  false );
            }
        }
        assertTrue( !itFwd.hasNext() && !itBck.hasNext() );
    }}

Ver también: test_iterJava::test_palindrome(); isPalindrome();

Definición en la línea 66 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::isForward ( ) const

inline

Retorna true si la iteración es natural, desde el primero al útlimo.

Definición en la línea 75 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::isReverse ( ) const

inline

Retorna true si la iteración va hacia atrás, en reversa.

   - Solo después de que \c setReverse() ocurrirá que \c isReverse() retorne \c true.

    {{  // test::setReverse()
        std::list<long> L = makeList_long( "( 1 2 3 4 5 )" );
        typedef std::list<long>::const_iterator Iter;
        iterJava< Iter > itFwd, itBck;
        itFwd.set(L);
        assertTrue( itFwd.next() == 1 ); // next() !
        itFwd.setReverse();              // NOP !!!
        assertTrue( itFwd.isForward() );
        itBck.set(L); itBck.setReverse();
        assertTrue( !itBck.isForward() );
        assertTrue(  itBck.isBackward() && itBck.isReverse() );
        assertTrue(  itBck.next() == 5 );
        itFwd.set(L); itFwd.setReverse();
        assertTrue( ! itFwd.isForward() && itFwd.isReverse() );
    }}

Ver también: test_iterJava::test_setReverse()

Definición en la línea 76 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::setBackward ( )

inline

Establece que el iterador irá hacia atrás, en reversa.

Precondición

No debe invocarse el método next() antes de usar setBackward().

Cómodo sinónimo de setReverse().

Definición en la línea 77 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::isBackward ( ) const

inline

Retorna true si la iteración va hacia atrás, en reversa.

   - Solo después de que \c setBackward() ocurrirá que \c isBackward() retorne \c true.
   - Cómodo sinónimo de \c isReverse().

    {{  // test::setReverse()
        std::list<long> L = makeList_long( "( 1 2 3 4 5 )" );
        typedef std::list<long>::const_iterator Iter;
        iterJava< Iter > itFwd, itBck;
        itFwd.set(L);
        assertTrue( itFwd.next() == 1 ); // next() !
        itFwd.setReverse();              // NOP !!!
        assertTrue( itFwd.isForward() );
        itBck.set(L); itBck.setReverse();
        assertTrue( !itBck.isForward() );
        assertTrue(  itBck.isBackward() && itBck.isReverse() );
        assertTrue(  itBck.next() == 5 );
        itFwd.set(L); itFwd.setReverse();
        assertTrue( ! itFwd.isForward() && itFwd.isReverse() );
    }}

Ver también: test_iterJava::test_setReverse()

Definición en la línea 78 del archivo iterJava.h.

Documentación de las funciones relacionadas y clases amigas

template<typename Iter>

bool operator==	(	const iterJava< Iter > &	l,
		const iterJava< Iter > &	r
	)

friend

( l == r ) ?

Definición en la línea 81 del archivo iterJava.h.

template<typename Iter>

bool operator!=	(	const iterJava< Iter > &	l,
		const iterJava< Iter > &	r
	)

friend

( l != r ) ?

Definición en la línea 87 del archivo iterJava.h.

Documentación de los datos miembro

template<typename Iter>

iterJava< Iter >::itPrev

protected

Recuerda el último valor retornado.

Definición en la línea 25 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::itNext

protected

Siguiente valor por retornar.

Definición en la línea 26 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::itEnd

protected

Pasado del último valor.

Definición en la línea 27 del archivo iterJava.h.

template<typename Iter>

iterJava< Iter >::isFwd

protected

"false" si es un reverse_iterator.

Definición en la línea 28 del archivo iterJava.h.

La documentación para esta clase fue generada a partir del siguiente fichero:

iterJava.h

Métodos públicos

Atributos protegidos

Amigas

Descripción detallada

template<typename Iter> class iterJava< Iter >

Documentación del constructor y destructor

Documentación de las funciones miembro

Documentación de las funciones relacionadas y clases amigas

Documentación de los datos miembro

template<typename Iter>
class iterJava< Iter >