xmog_java_field.h

//
// Copyright (c) 1999-2020 by Codemesh, Inc.. ALL RIGHTS RESERVED.
//
 
 
#ifndef xmog_java_field_inc
#define xmog_java_field_inc
 
 
class xmog_java_class;
 
 
#include "xmog_java_dynamic.h"
#include "xmog_java_string.h"
 
 
class XMOG_DECLSPEC xmog_java_field : public xmog_java_dynamic
{
private:
 
    jfieldID        fid_;
 
    xmog_java_class * clazz_;
 
    xmog_java_field * next_;
 
    char *          name_;
 
    char *          type_;
 
    bool            bStatic_;
 
public:
 
    friend class xmog_java_class;
 
    xmog_java_field( xmog_java_class * clazz, jfieldID fid, bool bStatic = false );
 
    xmog_java_field( xmog_java_class * clazz, const char * name, const char * type, bool bStatic = false );
 
    ~xmog_java_field();
 
    void *          operator new ( size_t );
 
    void            operator delete( void * );
 
    xmog_java_field *   next();
 
    xmog_java_class *   clazz();
 
    const char *        name();
 
    const char *        type();
 
    bool            is_static() const;
 
    void            set_fieldID( jfieldID fid );
 
    jfieldID        get_fieldID();
 
    int             initializeFieldID( xmog_localenv * env );
 
    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_bool : public xmog_base
{
private:
 
    bool        theValue_;
 
public:
 
    xmog_bool( xmog_java_array * _ref, jint _index );
 
    xmog_bool( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator bool() const;
 
    bool    operator * () const;
 
    xmog_bool & operator = ( bool );
 
    bool    get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void    set( bool b, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_jboolean : public xmog_base
{
private:
 
    jboolean        theValue_;
 
public:
 
    xmog_jboolean( xmog_java_array * _ref, jint _index );
 
    xmog_jboolean( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jboolean() const;
 
    jboolean    operator * () const;
 
    xmog_jboolean & operator = ( jboolean );
 
    jboolean    get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void    set( jboolean b, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_byte : public xmog_base
{
private:
 
    jbyte       theValue_;
 
public:
 
    xmog_byte( xmog_java_array * _ref, jint _index );
 
    xmog_byte( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jbyte() const;
 
    jbyte   operator * () const;
 
    xmog_byte & operator = ( jbyte );
 
    xmog_byte & operator |= ( jbyte );
 
    xmog_byte & operator &= ( jbyte );
 
    xmog_byte & operator ^= ( jbyte );
 
    xmog_byte &    operator ++ ();
 
    xmog_byte &    operator -- ();
 
    jbyte          operator ++ (int);
 
    jbyte          operator -- (int);
 
    xmog_byte & operator += ( jbyte );
 
    xmog_byte & operator -= ( jbyte );
 
    xmog_byte & operator *= ( int );
 
    xmog_byte &    operator /= ( int );
 
    xmog_byte &    operator %= ( int );
 
    xmog_byte &    operator <<= ( int );
 
    xmog_byte &    operator >>= ( int );
 
    jbyte   get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void    set( jbyte b, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_char : public xmog_base
{
private:
 
    jchar       theValue_;
 
public:
 
    xmog_char( xmog_java_array * _ref, jint _index );
 
    xmog_char( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator int() const;
 
    int operator * () const;
 
    xmog_char & operator = ( int );
 
    xmog_char & operator |= ( int );
 
    xmog_char & operator &= ( int );
 
    xmog_char & operator ^= ( int );
 
    xmog_char &    operator ++ ();
 
    xmog_char &    operator -- ();
 
    jchar          operator ++ (int);
 
    jchar          operator -- (int);
 
    xmog_char & operator += ( int );
 
    xmog_char & operator -= ( int );
 
    xmog_char & operator *= ( int );
 
    xmog_char & operator /= ( int );
 
    xmog_char &    operator %= ( int );
 
    xmog_char &    operator <<= ( int );
 
    xmog_char &    operator >>= ( int );
 
    int     get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void    set( int c, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_double : public xmog_base
{
private:
 
    jdouble     theValue_;
 
public:
 
    xmog_double( xmog_java_array * _ref, jint _index );
 
    xmog_double( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jdouble() const;
 
    jdouble operator * () const;
 
    xmog_double &   operator = ( jdouble );
 
    xmog_double &   operator += ( jdouble );
 
    xmog_double &   operator -= ( jdouble );
 
    xmog_double &   operator *= ( jdouble );
 
    xmog_double &   operator /= ( jdouble );
 
    jdouble     get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void        set( jdouble d, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_float : public xmog_base
{
private:
 
    jfloat      theValue_;
 
public:
 
    xmog_float( xmog_java_array * _ref, jint _index );
 
    xmog_float( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jfloat() const;
 
    jfloat  operator * () const;
 
    xmog_float &    operator = ( jfloat );
 
    xmog_float &    operator += ( jfloat );
 
    xmog_float &    operator -= ( jfloat );
 
    xmog_float &    operator *= ( jfloat );
 
    xmog_float &    operator /= ( jfloat );
 
    jfloat      get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void        set( jfloat f, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_int : public xmog_base
{
private:
 
    jint        theValue_;
 
public:
 
    xmog_int( xmog_java_array * _ref, jint _index );
 
    xmog_int( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jint() const;
 
    jint    operator * () const;
 
    xmog_int &  operator = ( jint );
 
    xmog_int &  operator &= ( jint );
 
    xmog_int &  operator |= ( jint );
 
    xmog_int &  operator ^= ( jint );
 
    xmog_int &  operator %= ( jint );
 
    xmog_int &  operator >>= ( int );
 
    xmog_int &  operator <<= ( int );
 
    xmog_int  &    operator ++ ();
 
    xmog_int  &    operator -- ();
 
    jint           operator ++ (int);
 
    jint          operator -- (int);
 
    xmog_int &  operator += ( jint );
 
    xmog_int &  operator -= ( jint );
 
    xmog_int &  operator *= ( jint );
 
    xmog_int &  operator /= ( jint );
 
    jint        get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void        set( jint i, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_long : public xmog_base
{
private:
 
    jlong       theValue_;
 
public:
 
    xmog_long( xmog_java_array * _ref, jint _index );
 
    xmog_long( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jlong() const;
 
    jlong   operator * () const;
 
    xmog_long & operator = ( jlong );
 
    xmog_long & operator &= ( jlong );
 
    xmog_long & operator |= ( jlong );
 
    xmog_long & operator ^= ( jlong );
 
    xmog_long & operator %= ( jlong );
 
    xmog_long & operator >>= ( int );
 
    xmog_long & operator <<= ( int );
 
    xmog_long &    operator ++ ();
 
    xmog_long &    operator -- ();
 
    jlong          operator ++ (int);
 
    jlong          operator -- (int);
 
    xmog_long & operator += ( jlong );
 
    xmog_long & operator -= ( jlong );
 
    xmog_long & operator *= ( jlong );
 
    xmog_long & operator /= ( jlong );
 
    jlong       get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void        set( jlong l, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
class XMOG_DECLSPEC xmog_short : public xmog_base
{
private:
 
    jshort      theValue_;
 
public:
 
    xmog_short( xmog_java_array * _ref, jint _index );
 
    xmog_short( xmog_java_ref * _clazz_ref_array, xmog_java_dynamic * _dynamic, xmog_flags _flags = 0 ); 
 
    operator jshort() const;
 
    jshort  operator * () const;
 
    xmog_short &    operator = ( jshort );
 
    xmog_short &    operator &= ( jshort );
 
    xmog_short &    operator |= ( jshort );
 
    xmog_short &    operator ^= ( jshort );
 
    xmog_short &    operator %= ( jshort );
 
    xmog_short &    operator >>= ( int );
 
    xmog_short &    operator <<= ( int );
 
    xmog_short &    operator ++ ();
 
    xmog_short &    operator -- ();
 
    jshort         operator ++ (int);
 
    jshort         operator -- (int);
 
    xmog_short &    operator += ( jshort );
 
    xmog_short &    operator -= ( jshort );
 
    xmog_short &    operator *= ( jshort );
 
    xmog_short &    operator /= ( jshort );
 
    jshort      get( xmog_localenv * env = NULL, bool readThrough = false ) const;
 
    void        set( jshort s, xmog_localenv * env = NULL, bool writeThrough = false );
};
 
 
template < class FieldType > class xmog_field_t : public xmog_java_ref
{
public:
    
    xmog_field_t( xmog_java_ref * _inst, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL ) :
        xmog_java_ref( _inst, _dynamic, _flags )
    {
    }
 
    FieldType   operator = ( const FieldType & _inst )
    {
        this->copy_jobject_( &_inst );
    }
 
    FieldType   operator = ( const xmog_null & _null_inst )
    {
        xmog_base   temp;
 
        this->set_jobject_( &temp );
    }
 
    operator FieldType() const
    {
        return FieldType( (xmog_java_ref*)XMOG_JOBJECT_VALUE(owner_), dynamic_, flags_ );
    }
 
    FieldType   operator * () const
    {
        return FieldType( (xmog_java_ref*)XMOG_JOBJECT_VALUE(owner_), dynamic_, flags_ );
    }
 
    operator FieldType()
    {
        return FieldType( (xmog_java_ref*)XMOG_JOBJECT_VALUE(owner_), dynamic_, flags_ );
    }
 
};
 
 
template < class FieldType > class xmog_string_field_t : public xmog_field_t< FieldType >
{
public:
    
    xmog_string_field_t( xmog_java_ref * _inst, xmog_java_dynamic * _dynamic, xmog_flags _flags = xmog_base::GLOBAL ) :
        xmog_field_t< FieldType>( _inst, _dynamic, _flags )
    {
    }
 
    FieldType   operator = ( const char * _str )
    {
        xmog_java_string::from_char( (xmog_base*)this, xmog_base::GLOBAL, _str, -1, NULL );
        return this->operator FieldType();
    }
 
#   if (XMOG_SUPPORTS_WCHAR_T==1)
    FieldType   operator = ( const XMOG_WCHAR * _wstr )
    {
        xmog_java_string::from_wchar( (xmog_base*)this, xmog_base::GLOBAL, _wstr, -1, NULL );
        return this->operator FieldType();
    }
#   endif
 
#   if (XMOG_REQUIRES_UNSIGNED_SHORT_OVERLOAD==1)
    FieldType   operator = ( const unsigned short * _wstr )
    {
        xmog_java_string::from_wchar( (xmog_base*)this, xmog_base::GLOBAL, (XMOG_WCHAR*)_wstr, -1, NULL );
        return this->operator FieldType();
    }
#   endif
 
};
 
#endif /* xmog_java_field_inc */