IsNull() public static method

public static IsNull ( JniHandle handle ) : bool
handle JniHandle
return bool
Esempio n. 1
0
        public static float[] ArrayPrimJ2Cfloat(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new float[length];

            env.GetFloatArrayRegion(array, 0, length, res);
            return(res);
        }
Esempio n. 2
0
        public static double[] ArrayPrimJ2Cdouble(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new double[length];

            env.GetDoubleArrayRegion(array, 0, length, res);
            return(res);
        }
Esempio n. 3
0
        public static long[] ArrayPrimJ2Clong(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new long[length];

            env.GetLongArrayRegion(array, 0, length, res);
            return(res);
        }
Esempio n. 4
0
        public static char[] ArrayPrimJ2Cchar(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new char[length];

            env.GetCharArrayRegion(array, 0, length, res);
            return(res);
        }
Esempio n. 5
0
        public static bool[] ArrayPrimJ2Cboolean(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new bool[length];

            env.GetBooleanArrayRegion(array, 0, length, res);
            return(res);
        }
Esempio n. 6
0
        public static string[] ArrayStrongJp2CString(JNIEnv env, JniLocalHandle array)
        {
            if (JniLocalHandle.IsNull(array))
            {
                return(null);
            }
            int length = env.GetArrayLength(array);
            var res    = new string[length];

            for (int i = 0; i < length; i++)
            {
                JniLocalHandle elementPtr = env.GetObjectArrayElementPtr(array, i);
                String         element    = StrongJp2CString(env, elementPtr);
                res.SetValue(element, i);
            }
            return(res);
        }
Esempio n. 7
0
        public static TRes FullJ2C <TRes>(JNIEnv env, JniLocalHandle obj)
        {
            if (JniLocalHandle.IsNull(obj))
            {
                return(default(TRes));
            }
            Type reqType = typeof(TRes);

            if (reqType.IsPrimitive)
            {
                return((TRes)PrimJ2C(obj, env, reqType));
            }
#if DEBUG
            if (reqType.IsArray)
            {
                throw new InvalidOperationException("Call ArrayFullJ2C<TRes, TElem> instead");
            }
#endif
            Class clazz = env.GetObjectClass(obj);
            if (reqType == typeof(string) && clazz == String._class)
            {
                return((TRes)(object)StrongJ2CString(env, obj));
            }

            //now we deal only with JVM instances
            RegistryRecord record = Registry.GetJVMRecord(clazz);
            if (reqType.IsAssignableFrom(record.CLRInterface))
            {
                return((TRes)record.CreateCLRProxy(env, obj));
            }
            record = Registry.GetCLRRecord(reqType);
            if (Bridge.Setup.Debug)
            {
                if (!record.JVMInterface.isAssignableFrom(clazz))
                {
                    throw new InvalidCastException("Can't cast JVM instance" + clazz + " to " + reqType);
                }
            }
            return((TRes)record.CreateCLRProxy(env, obj));
        }
Esempio n. 8
0
        public static TRes FullJ2C <TRes>(JNIEnv env, JniLocalHandle obj)
        {
            if (JniLocalHandle.IsNull(obj))
            {
                return(default(TRes));
            }
            Type reqType = typeof(TRes);

            if (reqType.IsPrimitive)
            {
                return((TRes)PrimJ2C(obj, env, reqType));
            }
#if DEBUG
            if (reqType.IsArray)
            {
                throw new InvalidOperationException("Call ArrayFullJ2C<TRes, TElem> instead");
            }
#endif
            Class clazz = env.GetObjectClass(obj);
            if (reqType == typeof(string) && clazz == String._class)
            {
                return((TRes)(object)StrongJp2CString(env, obj));
            }

            if (IClrProxy_._class.isAssignableFrom(clazz))
            {
                if (!reqType.IsInterface && typeof(IJvmProxy).IsAssignableFrom(reqType))
                {
                    //now we double wrap
                    return((TRes)__IClrProxy.CreateProxy(env, obj));
                }
                object res = __IClrProxy.GetObject(env, obj);
                if (res == null && Delegate_._class.isAssignableFrom(clazz))
                {
                    //that's delegate implemented in Java
                    RegistryRecord delRecord = Registry.GetJVMRecord(clazz);
                    IJvmProxy      jvmProxy  = delRecord.CreateCLRProxy(env, obj);
                    Delegate       del       = Delegate.CreateDelegate(delRecord.CLRInterface, jvmProxy, delRecord.JVMDelegateInvoke);
                    return((TRes)(object)del);
                }
                if (Bridge.Setup.Debug)
                {
                    Type realType = res.GetType();
                    if (!reqType.IsAssignableFrom(realType))
                    {
                        throw new InvalidCastException("Can't cast CLR instance" + realType + " to " + reqType);
                    }
                }
                return((TRes)res);
            }

            //now we deal only with JVM instances
            RegistryRecord record = Registry.GetJVMRecord(clazz);
            if (reqType.IsAssignableFrom(record.CLRInterface))
            {
                return((TRes)record.CreateCLRProxy(env, obj));
            }
            record = Registry.GetCLRRecord(reqType);
            if (Bridge.Setup.Debug)
            {
                if (!record.JVMInterface.isAssignableFrom(clazz))
                {
                    throw new InvalidCastException("Can't cast JVM instance" + clazz + " to " + reqType);
                }
            }
            return((TRes)record.CreateCLRProxy(env, obj));
        }