xmog_iterator.h

/*
 * Copyright 1999-2006 by Codemesh, Inc.  ALL RIGHTS RESERVED.
 */
#ifndef xmog_iterator_inc
#define xmog_iterator_inc


#include "xmog_java_client.h"


struct Iterator_tag {};


struct Enumeration_tag {};


class XMOG_DECLSPEC xmog_iterator_base
{
private:

    xmog_base           collection_;
    xmog_base           iterator_;
    xmog_base           current_;

    const xmog_java_class * clazz_;
    xmog_java_method *  next_;
    xmog_java_method *  hasNext_;
    xmog_java_method *  previous_;
    xmog_java_method *  hasPrevious_;
    xmog_java_method *  size_;
    jint                index_;

    void                init( xmog_localenv * env );

protected:

    void                copy( const xmog_iterator_base & rhs );

    jobject             inner_current( xmog_localenv * env = NULL, xmog_flags flags = xmogDefaultFlags );

    void                inner_next( xmog_localenv * env = NULL, xmog_flags flags = xmogDefaultFlags );

    bool                inner_hasNext( xmog_localenv * env = NULL );

    void                inner_previous( xmog_localenv * env = NULL, xmog_flags flags = xmogDefaultFlags );

    bool                inner_hasPrevious( xmog_localenv * env = NULL );

    jint                inner_size( xmog_localenv * env = NULL ) const;

public:

    enum            
    {
        xmogDefaultFlags = xmog_base::GLOBAL,
        BEGIN_INDEX = -1,
        END_INDEX = -2,
        RBEGIN_INDEX = -3,
        REND_INDEX = -4
    };

    xmog_iterator_base();

    xmog_iterator_base( const xmog_base & collection, const xmog_java_class & clazz, jint ind );

    xmog_iterator_base( const xmog_iterator_base & rhs );

    xmog_iterator_base( const xmog_iterator_base & rhs, bool inc, bool dec );

    ~xmog_iterator_base();

    bool            operator != ( const xmog_iterator_base & rhs ) const;

    bool            operator == ( const xmog_iterator_base & rhs ) const;

    bool            operator < ( const xmog_iterator_base & rhs ) const;

    bool            operator <= ( const xmog_iterator_base & rhs ) const;

    bool            operator > ( const xmog_iterator_base & rhs ) const;

    bool            operator >= ( const xmog_iterator_base & rhs ) const;

};


template< typename Elem >
class xmog_iterator : public xmog_iterator_base
{
private:

    Elem            current;

public:

    xmog_iterator<Elem>() :
        xmog_iterator_base(),
        current()
    {
    }

    xmog_iterator<Elem>( const xmog_base & collection, const xmog_java_class & clazz, jint ind ) :
        xmog_iterator_base( collection, clazz, ind ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    xmog_iterator<Elem>( const xmog_iterator<Elem> & rhs ) :
        xmog_iterator_base( rhs ),
        current( rhs.current )
    {
    }

    xmog_iterator<Elem>( const xmog_iterator<Elem> & rhs, bool inc ) :
        xmog_iterator_base( rhs, true, false ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    ~xmog_iterator<Elem>()
    {
    }

    xmog_iterator<Elem> &   operator = ( const xmog_iterator<Elem> & rhs )
    {
        copy( rhs );
        current = rhs.current;
        return *this;
    }

    operator Elem & ()
    {
        return current;
    }

    Elem &  operator * ()
    {
        return current;
    }

    const Elem &    operator * () const
    {
        return current;
    }

    Elem *  operator -> ()
    {
        return &current;
    }

    Elem * const    operator -> () const
    {
        return &current;
    }
    
    xmog_iterator<Elem> &   operator ++ ()
    {
        inner_next();
        current = Elem( inner_current(), xmogDefaultFlags );
        return *this;
    }
    
    xmog_iterator<Elem> operator ++ ( int )
    {
        xmog_iterator<Elem>     result( *this );
        inner_next();
        current = Elem( inner_current(), xmogDefaultFlags );
        return result;
    }
};


template< typename Elem >
class xmog_reverse_iterator : public xmog_iterator_base
{
private:

    Elem            current;

public:

    xmog_reverse_iterator<Elem>() :
        xmog_iterator_base(),
        current()
    {
    }

    xmog_reverse_iterator<Elem>( const xmog_base & collection, const xmog_java_class & clazz, jint ind ) :
        xmog_iterator_base( collection, clazz, ind ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    xmog_reverse_iterator<Elem>( const xmog_reverse_iterator<Elem> & rhs ) :
        xmog_iterator_base( rhs ),
        current( rhs.current )
    {
    }

    xmog_reverse_iterator<Elem>( const xmog_reverse_iterator<Elem> & rhs, bool dec ) :
        xmog_iterator_base( rhs, false, true ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    ~xmog_reverse_iterator<Elem>()
    {
    }

    xmog_reverse_iterator<Elem> &   operator = ( const xmog_reverse_iterator<Elem> & rhs )
    {
        copy( rhs );
        current = rhs.current;
        return *this;
    }

    operator Elem & ()
    {
        return current;
    }

    Elem &  operator * ()
    {
        return current;
    }

    const Elem &    operator * () const
    {
        return current;
    }

    Elem * const    operator -> () const
    {
        return &current;
    }
    
    xmog_reverse_iterator<Elem> &   operator -- ()
    {
        inner_previous();
        current = Elem( inner_current(), xmogDefaultFlags );
        return *this;
    }
    
    xmog_reverse_iterator<Elem> operator -- ( int )
    {
        xmog_reverse_iterator<Elem>     result( *this );
        inner_previous();
        current = Elem( inner_current(), xmogDefaultFlags );
        return result;
    }
};


template< typename Elem >
class xmog_bidir_iterator : public xmog_iterator_base
{
private:

    Elem            current;

public:

    xmog_bidir_iterator<Elem>() :
        xmog_iterator_base(),
        current()
    {
    }

    xmog_bidir_iterator<Elem>( const xmog_base & collection, const xmog_java_class & clazz, jint ind ) :
        xmog_iterator_base( collection, clazz, ind ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    xmog_bidir_iterator<Elem>( const xmog_bidir_iterator<Elem> & rhs ) :
        xmog_iterator_base( rhs ),
        current( rhs.current )
    {
    }

    xmog_bidir_iterator<Elem>( const xmog_bidir_iterator<Elem> & rhs, bool inc, bool dec ) :
        xmog_iterator_base( rhs, inc, dec ),
        current( inner_current(), xmogDefaultFlags )
    {
    }

    ~xmog_bidir_iterator<Elem>()
    {
    }

    xmog_bidir_iterator<Elem> & operator = ( const xmog_bidir_iterator<Elem> & rhs )
    {
        copy( rhs );
        current = rhs.current;
        return *this;
    }

    operator Elem & ()
    {
        return current;
    }

    Elem &  operator * ()
    {
        return current;
    }

    Elem *  operator -> ()
    {
        return &current;
    }
    
    xmog_bidir_iterator<Elem> & operator ++ ()
    {
        inner_next();
        current = Elem( inner_current(), xmogDefaultFlags );
        return *this;
    }
    
    xmog_bidir_iterator<Elem> operator ++ ( int )
    {
        xmog_bidir_iterator<Elem>       result( *this );
        inner_next();
        current = Elem( inner_current(), xmogDefaultFlags );
        return result;
    }
    
    xmog_bidir_iterator<Elem> & operator -- ()
    {
        inner_previous();
        current = Elem( inner_current(), xmogDefaultFlags );
        return *this;
    }
    
    xmog_bidir_iterator<Elem> operator -- ( int )
    {
        xmog_bidir_iterator<Elem>       result( *this );
        inner_previous();
        current = Elem( inner_current(), xmogDefaultFlags );
        return result;
    }
};

#if (XMOG_SUPPORTS_STL == 1)

#include <iterator>

template< typename Elem > struct std::iterator_traits< xmog_iterator< Elem > >
{
    typedef ptrdiff_t   difference_type;
    typedef Elem        value_type;
    typedef Elem*       pointer;
    typedef Elem&       reference;
    typedef std::forward_iterator_tag iterator_category; 
};

template< typename Elem > struct std::iterator_traits< xmog_bidir_iterator< Elem > >
{
    typedef ptrdiff_t   difference_type;
    typedef Elem        value_type;
    typedef Elem*       pointer;
    typedef Elem&       reference;
    typedef std::bidirectional_iterator_tag iterator_category; 
};

#endif /* XMOG_SUPPORTS_STL */

#endif /* ifndef xmog_iterator_inc */

---