Exemple #1
0
func jObjectValue(v interface{}) (C.jvalue, error) {
	rv := reflect.ValueOf(v)
	if !rv.IsValid() { // nil value
		return C.jObjectValue(nil), nil
	}
	switch val := v.(type) {
	case Object:
		return C.jObjectValue(val.value()), nil
	case Class:
		return C.jObjectValue(C.jobject(val.value())), nil
	default:
		return errJValue, fmt.Errorf("%#v isn't Object or Class", v)
	}
}
Exemple #2
0
func jVExceptionValue(env Env, v interface{}) (C.jvalue, error) {
	if v == nil {
		return C.jObjectValue(nil), nil
	}
	native, ok := v.(error)
	if !ok {
		return errJValue, fmt.Errorf("%#v isn't error", v)
	}
	jVException, err := JVException(env, native)
	if err != nil {
		return errJValue, err
	}
	return jObjectValue(jVException)
}
Exemple #3
0
// }
// jvalue jFloatValue(jfloat val) {
//   jvalue ret = { .f = val };
//   return ret;
// }
// jvalue jDoubleValue(jdouble val) {
//   jvalue ret = { .d = val };
//   return ret;
// }
// jvalue jObjectValue(jobject val) {
//   jvalue ret = { .l = val };
//   return ret;
// }
import "C"

var errJValue = C.jObjectValue(nil)

// jValue converts a Go value into a Java value with the given sign.
func jValue(env Env, v interface{}, sign Sign) (C.jvalue, error) {
	switch sign {
	case BoolSign:
		return jBoolValue(v)
	case ByteSign:
		return jByteValue(v)
	case CharSign:
		return jCharValue(v)
	case ShortSign:
		return jShortValue(v)
	case IntSign:
		return jIntValue(v)
	case LongSign: