xmog_java_field.h

/*
 * Copyright 1999-2006 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 += ( jbyte );

    xmog_byte & operator -= ( jbyte );

    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 += ( 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 += ( 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 += ( 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 += ( 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 */

---