xmog_java_array.h

/*
 * Copyright 1999-2006 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"




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, 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, 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( jbyte * buffer, jint size, 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, 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, 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, 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, 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, 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, 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 */

---