xmog_java_array.h

//
// Copyright (c) 1999-2020 by Codemesh, Inc.. ALL RIGHTS RESERVED.
//
 
 
#ifndef xmog_java_array_inc
#define xmog_java_array_inc
 
 
#include "xmog.h"
#include "xmog_base.h"
#include "xmog_java_ref.h"
#include "xmog_java_dynamic.h"
#include "xmog_java_class.h"
 
 
 
 
class xmog_java_array;
struct xmog_java_values;
class xmog_localenv;
class xmog_bool;
class xmog_jboolean;
class xmog_byte;
class xmog_char;
class xmog_double;
class xmog_float;
class xmog_int;
class xmog_long;
class xmog_short;
class xmog_null;
 
 
 
class XMOG_DECLSPEC xmog_java_element : public xmog_java_dynamic
{
public:
 
    static xmog_java_element    theElement;
 
    xmog_java_element();
 
    ~xmog_java_element();
 
    virtual bool    get_bool( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jboolean get_jboolean( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jbyte   get_byte( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jchar   get_char( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jdouble get_double( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jfloat  get_float( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jint    get_int( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jlong   get_long( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jshort  get_short( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual jobject get_jobject( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = xmog_base::GLOBAL ) ;
 
    virtual void    get_void( xmog_base * obj, xmog_java_values * args = NULL, xmog_localenv * env = NULL, xmog_flags flags = 0 ) ;
 
    virtual void    set_bool( xmog_base * obj, bool b, xmog_localenv * env = NULL ) ;
 
    virtual void    set_jboolean( xmog_base * obj, jboolean b, xmog_localenv * env = NULL ) ;
 
    virtual void    set_byte( xmog_base * obj, jbyte b, xmog_localenv * env = NULL ) ;
 
    virtual void    set_char( xmog_base * obj, jchar ch, xmog_localenv * env = NULL ) ;
 
    virtual void    set_double( xmog_base * obj, jdouble d, xmog_localenv * env = NULL ) ;
 
    virtual void    set_float( xmog_base * obj, jfloat f, xmog_localenv * env = NULL ) ;
 
    virtual void    set_int( xmog_base * obj, jint i, xmog_localenv * env = NULL ) ;
 
    virtual void    set_long( xmog_base * obj, jlong l, xmog_localenv * env = NULL ) ;
 
    virtual void    set_short( xmog_base * obj, jshort sh, xmog_localenv * env = NULL ) ;
 
    virtual void    set_jobject( xmog_base * obj, jobject o, xmog_localenv * env = NULL ) ;
};
 
 
class XMOG_DECLSPEC xmog_java_array_size
{
private:
 
    xmog_java_array *   owner_;
 
    XMOG_MUTABLE jint   size_;
 
public:
 
    friend class xmog_java_array;
 
    XMOG_EXPLICIT   xmog_java_array_size( xmog_java_array * owner, jint size = -1 );
 
    operator jint() const;
 
    jint        to_jint( xmog_localenv * env ) const;
};
 
 
class XMOG_DECLSPEC xmog_java_array : public xmog_java_ref
{
public:
 
    xmog_java_array();
 
    xmog_java_array( jobject array, xmog_flags flags, jint size = -1, xmog_localenv * env = NULL );
 
    xmog_java_array( const xmog_null & ); 
 
    xmog_java_array( const xmog_java_array & _rhs, xmog_localenv * env = NULL ); 
 
    xmog_java_array( xmog_java_array * _arr, jint _index );
 
    xmog_java_array( xmog_java_class * _clazz, xmog_java_dynamic * _dynamic, xmog_flags _flags );
 
    xmog_java_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_array( xmog_java_ref * _ref, xmog_java_dynamic * _dynamic, xmog_flags _flags );
 
    ~xmog_java_array();
 
    xmog_java_array_size        length;
 
    jint                        get_length( xmog_localenv * env ) const;
 
    void                        xmog_invalidate( xmog_localenv * env = NULL );
 
protected:
 
    void    copy_( const xmog_java_array & _rhs, xmog_localenv * env = NULL );
 
private:
 
    void *                      ptr_;
};
 
 
template< class ArrayType >
class xmog_array_iterator
{
private:
 
    ArrayType           array_;
 
    jint                index_;
 
public:
 
    typedef typename ArrayType::difference_type difference_type;
 
    typedef typename ArrayType::value_type      value_type;
 
    xmog_array_iterator< ArrayType >() :
        array_(),
        index_( -1 )
    {
    }
 
    xmog_array_iterator< ArrayType >( const xmog_array_iterator< ArrayType > & rhs ) :
        array_( rhs.array_ ),
        index_( rhs.index_ )
    {
    }
 
    xmog_array_iterator< ArrayType >( ArrayType & arr ) :
        array_( arr ),
        index_( 0 )
    {
    }
 
    xmog_array_iterator< ArrayType >( ArrayType & arr, jint ind ) :
        array_( arr ),
        index_( ind )
    {
        if( index_ == -1 && !array_.is_null_() )
            index_ = array_.length;
    }
 
    ~xmog_array_iterator< ArrayType > ()
    {
    }
 
    xmog_array_iterator< ArrayType> &   operator = ( const xmog_array_iterator< ArrayType > & rhs )
    {
        array_ = rhs.array_;
        index_ = rhs.index_;
        return *this;
    }
 
    bool    operator < ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return ( index_ != -1 && index_ < rhs.index_ ) || rhs.index_ == -1;
    }
 
    bool    operator <= ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return rhs.index_ == -1 || ( index_ != -1 && index_ <= rhs.index_ );
    }
 
    bool    operator > ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return ( rhs.index_ != -1 && rhs.index_ < index_ ) || index_ == -1;
    }
 
    bool    operator >= ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return index_ == -1 || ( rhs.index_ != -1 && rhs.index_ < index_ );
    }
 
    bool    operator == ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return ( index_ == rhs.index_ );
    }
 
    bool    operator != ( const xmog_array_iterator< ArrayType > & rhs ) const
    {
        return ( index_ != rhs.index_ );
    }
 
    xmog_array_iterator< ArrayType >    operator + ( difference_type diff )
    {
        return xmog_array_iterator< ArrayType >( array_, index_ + diff );
    }
 
    xmog_array_iterator< ArrayType > &  operator += ( difference_type diff )
    {
        index_ = index_ + diff;
        return *this;
    }
 
    xmog_array_iterator< ArrayType >    operator - ( difference_type diff )
    {
        return xmog_array_iterator< ArrayType >( array_, index_ - diff );
    }
 
    xmog_array_iterator< ArrayType > &  operator -= ( difference_type diff )
    {
        index_ = index_ - diff;
        return *this;
    }
 
    value_type operator[] ( jint ind )
    {
        return array_[ index_ + ind ];
    }
 
    value_type operator * ()
    {
        return array_[ index_ ];
    }
    
    xmog_array_iterator< ArrayType > &  operator ++ ()
    {
        ++index_;
        return *this;
    }
    
    xmog_array_iterator< ArrayType >    operator ++ ( int )
    {
        return xmog_array_iterator< ArrayType >( array_, index_++ );
    }
    
    xmog_array_iterator< ArrayType > &  operator -- ()
    {
        --index_;
        return *this;
    }
    
    xmog_array_iterator< ArrayType >    operator -- ( int )
    {
        return xmog_array_iterator< ArrayType >( array_, index_-- );
    }
 
};
 
 
class XMOG_DECLSPEC xmog_java_bool_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, bool * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_bool_array>   iterator;
 
    typedef xmog_bool   value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_bool_array();
 
    xmog_java_bool_array( const xmog_null & );
 
    xmog_java_bool_array( const xmog_java_bool_array &, xmog_localenv * env = NULL );
 
    xmog_java_bool_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_bool_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_bool_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_bool_array( jobject _local, xmog_flags _flags );
 
    xmog_java_bool_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_bool_array( bool * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_bool_array dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( bool * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );   
 
    void                        to_native( bool * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL ); 
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_bool       operator [] ( jint index );
 
    void            set( jint index, bool v, xmog_localenv * env = NULL );
 
    bool            operator [] ( jint index ) const;
 
    bool            get( jint index, xmog_localenv * env ) const;
 
    xmog_java_bool_array &  operator = ( const xmog_java_bool_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_jboolean_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jboolean * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_jboolean_array>   iterator;
 
    typedef xmog_jboolean   value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_jboolean_array();
 
    xmog_java_jboolean_array( const xmog_null & );
 
    xmog_java_jboolean_array( const xmog_java_jboolean_array &, xmog_localenv * env = NULL );
 
    xmog_java_jboolean_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_jboolean_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_jboolean_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_jboolean_array( jobject _local, xmog_flags _flags );
 
    xmog_java_jboolean_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_jboolean_array( jboolean * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_jboolean_array dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jboolean * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );   
 
    void                        to_native( jboolean * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL ); 
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_jboolean   operator [] ( jint index );
 
    void            set( jint index, jboolean v, xmog_localenv * env = NULL );
 
    jboolean        operator [] ( jint index ) const;
 
    jboolean        get( jint index, xmog_localenv * env ) const;
 
    xmog_java_jboolean_array &  operator = ( const xmog_java_jboolean_array & );
 
};
 
 
 
class XMOG_DECLSPEC xmog_java_byte_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jbyte * pData, xmog_flags flags, bool useNIO, xmog_localenv * env );
 
    xmog_base   buffer;
 
public:
 
    typedef xmog_array_iterator<xmog_java_byte_array>   iterator;
 
    typedef xmog_byte   value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_byte_array();
 
    xmog_java_byte_array( const xmog_null & );
 
    xmog_java_byte_array( const xmog_java_byte_array &, xmog_localenv * env = NULL );
 
    xmog_java_byte_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_byte_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_byte_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_byte_array( jobject _local, xmog_flags _flags );
 
    xmog_java_byte_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_byte_array( jbyte * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    xmog_java_byte_array( jbyte * arr, jsize size, bool useNIO, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    ~xmog_java_byte_array();
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_byte_array dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jbyte * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );  
 
    void                        to_native( jbyte * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );    
 
    void                        to_native_nio( jbyte ** dest_arr, jlong * length, xmog_localenv * env = NULL ); 
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_byte       operator [] ( jint index );
 
    void            set( jint index, jbyte v, xmog_localenv * env = NULL );
 
    jbyte           operator [] ( jint index ) const;
 
    jbyte           get( jint index, xmog_localenv * env ) const;
 
    xmog_java_byte_array &  operator = ( const xmog_java_byte_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_char_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jchar * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_char_array>   iterator;
 
    typedef xmog_char   value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_char_array();
 
    xmog_java_char_array( const xmog_null & );
 
    xmog_java_char_array( const xmog_java_char_array & , xmog_localenv * env = NULL );
 
    xmog_java_char_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_char_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_char_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_char_array( jobject _local, xmog_flags _flags );
 
    xmog_java_char_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_char_array( jchar * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_char_array dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jchar * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );  
 
    void                        to_native( jchar * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );    
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_char       operator [] ( jint index );
 
    void            set( jint index, jchar v, xmog_localenv * env = NULL );
 
    jchar           operator [] ( jint index ) const;
 
    jchar           get( jint index, xmog_localenv * env ) const;
 
    xmog_java_char_array &  operator = ( const xmog_java_char_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_double_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jdouble * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_double_array> iterator;
 
    typedef xmog_double value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_double_array();
 
    xmog_java_double_array( const xmog_null & );
 
    xmog_java_double_array( const xmog_java_double_array & , xmog_localenv * env = NULL );
 
    xmog_java_double_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_double_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_double_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_double_array( jobject _local, xmog_flags _flags );
 
    xmog_java_double_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_double_array( jdouble * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_double_array   dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jdouble * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );    
 
    void                        to_native( jdouble * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );  
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_double     operator [] ( jint index );
 
    void            set( jint index, jdouble v, xmog_localenv * env = NULL );
 
    jdouble         operator [] ( jint index ) const;
 
    jdouble         get( jint index, xmog_localenv * env ) const;
 
    xmog_java_double_array &    operator = ( const xmog_java_double_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_float_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jfloat * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_float_array>  iterator;
 
    typedef xmog_float  value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_float_array();
 
    xmog_java_float_array( const xmog_null & );
 
    xmog_java_float_array( const xmog_java_float_array & , xmog_localenv * env = NULL );
 
    xmog_java_float_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_float_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_float_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_float_array( jobject _local, xmog_flags _flags );
 
    xmog_java_float_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_float_array( jfloat * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_float_array    dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jfloat * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL ); 
 
    void                        to_native( jfloat * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );   
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_float      operator [] ( jint index );
 
    void            set( jint index, jfloat v, xmog_localenv * env = NULL );
 
    jfloat          operator [] ( jint index ) const;
 
    jfloat          get( jint index, xmog_localenv * env ) const;
 
    xmog_java_float_array & operator = ( const xmog_java_float_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_int_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jint * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_int_array>    iterator;
 
    typedef xmog_int    value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_int_array();
 
    xmog_java_int_array( const xmog_null & );
 
    xmog_java_int_array( const xmog_java_int_array & , xmog_localenv * env = NULL );
 
    xmog_java_int_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_int_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_int_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_int_array( jobject _local, xmog_flags _flags );
 
    xmog_java_int_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_int_array( jint * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_int_array  dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jint * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );   
 
    void                        to_native( jint * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL ); 
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_int        operator [] ( jint index );
 
    void            set( jint index, jint v, xmog_localenv * env = NULL );
 
    jint            operator [] ( jint index ) const;
 
    jint            get( jint index, xmog_localenv * env ) const;
 
    xmog_java_int_array &   operator = ( const xmog_java_int_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_long_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jlong * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_long_array>   iterator;
 
    typedef xmog_long   value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_long_array();
 
    xmog_java_long_array( const xmog_null & );
 
    xmog_java_long_array( const xmog_java_long_array & , xmog_localenv * env = NULL );
 
    xmog_java_long_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_long_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_long_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_long_array( jobject _local, xmog_flags _flags );
 
    xmog_java_long_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_long_array( jlong * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_long_array dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jlong * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL );  
 
    void                        to_native( jlong * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );    
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_long       operator [] ( jint index );
 
    void            set( jint index, jlong v, xmog_localenv * env = NULL );
 
    jlong           operator [] ( jint index ) const;
 
    jlong           get( jint index, xmog_localenv * env ) const;
 
    xmog_java_long_array &  operator = ( const xmog_java_long_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_short_array : public xmog_java_array
{
private:
 
    jarray      create( jint size, jshort * pData, xmog_flags flags, xmog_localenv * env );
 
public:
 
    typedef xmog_array_iterator<xmog_java_short_array>  iterator;
 
    typedef xmog_short  value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_short_array();
 
    xmog_java_short_array( const xmog_null & );
 
    xmog_java_short_array( const xmog_java_short_array & , xmog_localenv * env = NULL );
 
    xmog_java_short_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_short_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_short_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_short_array( jobject _local, xmog_flags _flags );
 
    xmog_java_short_array( jint size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL  );
 
    xmog_java_short_array( jshort * arr, jsize size, xmog_localenv * env = NULL, xmog_flags = xmog_base::GLOBAL );
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_short_array    dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL );
 
    void                        from_native( jshort * src_arr, jint dest_start, jsize length, xmog_localenv * env = NULL ); 
 
    void                        to_native( jshort * dest_arr, jint src_start, jsize length, xmog_localenv * env = NULL );   
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_short      operator [] ( jint index );
 
    void            set( jint index, jshort v, xmog_localenv * env = NULL );
 
    jshort          operator [] ( jint index ) const;
 
    jshort          get( jint index, xmog_localenv * env ) const;
 
    xmog_java_short_array & operator = ( const xmog_java_short_array & );
 
};
 
 
class XMOG_DECLSPEC xmog_java_object_array : public xmog_java_array
{
protected:
 
    jarray      create( jint size, xmog_java_class * clazz, xmog_flags flags, xmog_localenv * env );
 
public:
 
    xmog_java_object_array();
 
    xmog_java_object_array( const xmog_null & );
 
    xmog_java_object_array( const xmog_java_object_array & , xmog_localenv * env = NULL );
 
    xmog_java_object_array( xmog_java_array * _ref, jint _index );
 
    xmog_java_object_array( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL );
 
    xmog_java_object_array( xmog_base * _delegate, bool _owns_delegate = true );
 
    xmog_java_object_array( jobject _local, xmog_flags _flags );
 
    xmog_java_object_array( jint size, xmog_java_class * clazz, xmog_localenv * env = NULL, xmog_flags flags = xmog_base::GLOBAL  );
 
    static xmog_java_dynamic *  get_dynamic();
 
    static xmog_java_class *    get_class();
 
    static xmog_java_class *    get_element_java_class();
 
    xmog_java_ref   operator [] ( jint index );
 
    void            set( jint index, jobject v, xmog_localenv * env = NULL );
 
    jobject         operator [] ( jint index ) const;
 
    jobject         get( jint index, xmog_localenv * env ) const;
 
    xmog_java_object_array &    operator = ( const xmog_java_object_array & );
 
};
 
 
 
template < class ElementType > class xmog_holder_template : public ElementType 
{
public:
 
    xmog_holder_template<ElementType>( xmog_java_array * _ref, jint _index ) :
        ElementType( _ref, _index )
    {
        // explicit type specifier required for g++ 3.4+
        this->ElementType::owner_ = _ref;
        this->ElementType::index_ = _index;
        this->ElementType::flags_ = xmog_base::ARRAY_ELEMENT | xmog_base::CACHE_INVALID;
    }
 
    xmog_holder_template<ElementType>( const xmog_holder_template<ElementType> & _rhs ) :
        ElementType()
    {
        // explicit type specifier required for g++ 3.4+
        this->ElementType::owner_ = _rhs.owner_.value();
        this->ElementType::index_ = _rhs.index_;
        this->ElementType::flags_ = _rhs.flags_;
 
        // just to make sure, we release the object 
        ((ElementType&)_rhs).owner_ = 0;
    }
 
    ElementType     operator = ( const xmog_holder_template<ElementType> & _rhs )
    {
        return this->ElementType::operator = ( _rhs );
    }
 
    ElementType     operator = ( const ElementType & _rhs )
    {
        return this->ElementType::operator = ( _rhs );
    }
 
    ElementType &   operator * ()
    {
        return *this;
    }
};
 
 
template < class ElementType > class xmog_java_array_template : public xmog_java_object_array
{
public:
 
    typedef xmog_array_iterator< xmog_java_array_template< ElementType > >  iterator;
 
    typedef xmog_holder_template< ElementType > value_type;
 
    typedef ptrdiff_t   difference_type;
 
    xmog_java_array_template<ElementType>() :
        xmog_java_object_array()
    {
    }
 
    xmog_java_array_template<ElementType>( const xmog_null & ) :
        xmog_java_object_array()
    {
    }
 
    xmog_java_array_template<ElementType>( const xmog_java_array_template<ElementType> & _rhs, xmog_localenv * _env = NULL ) :
        xmog_java_object_array( _rhs, _env )
    {
    }
 
    XMOG_EXPLICIT xmog_java_array_template<ElementType>( xmog_java_array * _ref, jint _index ) :
        xmog_java_object_array( _ref, _index )
    {
    }
 
    XMOG_EXPLICIT xmog_java_array_template<ElementType>( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL ) :
        xmog_java_object_array( _clazz_ref_array, _dynamic, _flags )
    {
    }
 
    XMOG_EXPLICIT xmog_java_array_template<ElementType>( xmog_base * _delegate, bool bOwnsDelegate ) :
        xmog_java_object_array( _delegate, bOwnsDelegate )
    {
    }
 
    XMOG_EXPLICIT xmog_java_array_template<ElementType>( jobject _local, xmog_flags _flags ) :
        xmog_java_object_array( _local, _flags )
    {
    }
 
    XMOG_EXPLICIT xmog_java_array_template<ElementType>( jint size, xmog_localenv * env = NULL, xmog_flags flags = xmog_base::GLOBAL  ) :
        xmog_java_object_array( size, ElementType::get_class(), env, flags )
    {
        //owner_ = create( size, ElementType::get_class(), flags, env );
        //flags_ = xmog_base::STAND_ALONE | flags;
    }
 
    ~xmog_java_array_template<ElementType>()
    {
    }
 
    iterator    begin()
    {
        return iterator( *this, 0 );
    }
 
    iterator    end()
    {
        return iterator( *this, length );
    }
 
    static xmog_java_array_template<ElementType>    dyna_cast( const xmog_java_ref & _rhs, xmog_localenv * p_lxenv = NULL, xmog_flags flags = xmog_base::GLOBAL )
    {
        if( p_lxenv == NULL )
            p_lxenv = xmog_localenv::get_instance( p_lxenv );
        
        return xmog_java_array_template<ElementType>( get_class()->from( _rhs, flags, p_lxenv ), flags );
    }
 
    xmog_java_array_template<ElementType> & operator = ( const xmog_java_array_template<ElementType> & _rhs )
    {
        copy_( _rhs );
        return *this;
    }
 
    static xmog_java_dynamic *  get_dynamic()
    {
        return &xmog_java_element::theElement;
    }
 
    static xmog_java_class *    get_class()
    {
        return ElementType::get_class()->get_array_class();
    }
 
    static xmog_java_class *    get_element_java_class()
    {
        return ElementType::get_class();
    }
 
    xmog_holder_template<ElementType>       operator [] ( jint index )
    {
        return xmog_holder_template<ElementType>( (xmog_java_array*)this, index );
    }
 
 
    xmog_holder_template<ElementType>       operator [] ( jint index ) const
    {
        return xmog_holder_template<ElementType>( (xmog_java_array*)this, index );
    }
 
};
 
 
#if (XMOG_PRE_3_0_SUPPORT == 1 )
 
typedef xmog_java_bool_array    jcpp_bool_array;
 
typedef xmog_java_byte_array    jcpp_byte_array;
 
typedef xmog_java_char_array    jcpp_char_array;
 
typedef xmog_java_double_array  jcpp_double_array;
 
typedef xmog_java_float_array   jcpp_float_array;
 
typedef xmog_java_int_array     jcpp_int_array;
 
typedef xmog_java_long_array    jcpp_long_array;
 
typedef xmog_java_short_array   jcpp_short_array;
 
#endif
 
#endif /* xmog_java_array_inc */