xmog_iterator.h

//
// Copyright (c) 1999-2020 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 */