/// <summary>
        /// Unexports a previously exported object
        /// </summary>
        /// <param name="obj"><see cref="T:Java.Lang.Object" /></param>
        /// <param name="force">if set to <c>true</c> [force unexport].</param>
        /// <returns><c>true</c> if unexported, otherwise <c>false</c>.</returns>
        public static bool UnexportObject(JuggerNETProxyObject javaProxyObject, bool force)
        {
            jvalue[] args = new jvalue[2];

            using (JavaMethodArguments arguments = new JavaMethodArguments(args).Add(javaProxyObject).Add(force))
            {
                return mUnexportObject.CallBool(null, arguments);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="RMICacheChannelConnector"/> class.
        /// </summary>
        /// <param name="host">Tridion Cache Channel RMI Host</param>
        /// <param name="port">Tridion Cache Channel RMI Port</param>
        /// <param name="instanceIdentifier">Tridion Instance identifier.</param>
        public RMICacheChannelConnector(String host, int port, String instanceIdentifier)
            : base(JNIHandle.NULL)
        {
            jvalue[] args = new jvalue[3];

            using (JavaMethodArguments arguments = new JavaMethodArguments(args).Add(host).Add(port).Add(instanceIdentifier))
            {
                base.JObject = (long)mConstructor2.CallObject(this, arguments);
            }
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="CacheEvent" /> class.
        /// </summary>
        /// <param name="regionPath">Cache region path.</param>
        /// <param name="key">Cache key as <see cref="T:System.Int32" /></param>
        /// <param name="eventType"><see cref="T:TcmCDService.CacheTypes.CacheEventType" /></param>
        public CacheEvent(string regionPath, int key, CacheEventType eventType)
            : base(JNIHandle.NULL)
        {
            jvalue[] args = new jvalue[3];

            using (JavaMethodArguments arguments = new JavaMethodArguments(args).Add(regionPath).Add(new Java.Lang.Integer(key)).Add((int)eventType))
            {
                base.JObject = (long)mConstructor.CallObject(this, arguments);
            }
        }

        public CacheInvalidatorCallback(ICacheInvalidator cacheInvalidator)
        {
            _invalidator = cacheInvalidator;
            _callback = new GenericCallback((out int return_type, out jvalue return_value, IntPtr input) =>
            {
                try
                {
                    string key = (string)JavaClass.GetTypedInstance(typeof(string), jvalue.From(input).l);
                    _invalidator.Invalidate(key);

                    return_value = new jvalue();
                    return_type = 0;
                }
                catch (Exception exception)
                {
                    return_value = jvalue.CreateCBRetVal(exception);
                    return_type = 1;
                }

                return 0;
            });

            base.JObject = _constructor.construct(0, _callback);
        }

		internal static jdouble CallStaticDoubleMethodA(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args)
		{
			object o = InvokeHelper(pEnv, IntPtr.Zero, methodID, args, false);
			if(o != null)
			{
				return (jdouble)(double)o;
			}
			return 0;
		}

		internal static jboolean CallStaticBooleanMethodA(JNIEnv* pEnv, jclass clazz, jmethodID methodID, jvalue *args)
		{
			object o = InvokeHelper(pEnv, IntPtr.Zero, methodID, args, false);
			if(o != null)
			{
				return ((bool)o) ? JNI_TRUE : JNI_FALSE;
			}
			return JNI_FALSE;
		}

		internal static void CallNonvirtualVoidMethodA(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue* args)
		{
			InvokeHelper(pEnv, obj, methodID, args, true);
		}

		internal static jfloat CallNonvirtualFloatMethodA(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue* args)
		{
			object o = InvokeHelper(pEnv, obj, methodID, args, true);
			if(o != null)
			{
				return (jfloat)(float)o;
			}
			return 0;
		}

		internal static jobject CallNonvirtualObjectMethodA(JNIEnv* pEnv, jobject obj, jclass clazz, jmethodID methodID, jvalue*  args)
		{
			return pEnv->MakeLocalRef(InvokeHelper(pEnv, obj, methodID, args, true));
		}

		internal static jlong CallLongMethodA(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue* args)
		{
			object o = InvokeHelper(pEnv, obj, methodID, args, false);
			if(o != null)
			{
				return (jlong)(long)o;
			}
			return 0;
		}

		public static double CallDoubleMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		public static float CallFloatMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		public static char CallCharMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		public static byte CallByteMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		public static short CallShortMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		internal static jchar CallCharMethodA(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue* args)
		{
			object o = InvokeHelper(pEnv, obj, methodID, args, false);
			if(o != null)
			{
				return (jchar)(char)o;
			}
			return 0;
		}

		internal static jint CallIntMethodA(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue* args)
		{
			object o = InvokeHelper(pEnv, obj, methodID, args, false);
			if(o != null)
			{
				return (jint)(int)o;
			}
			return 0;
		}

		public static long CallLongMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}

		internal static void CallVoidMethodA(JNIEnv* pEnv, jobject obj, jmethodID methodID, jvalue*  args)
		{
			InvokeHelper(pEnv, obj, methodID, args, false);
		}

		public static void CallVoidMethod(IntPtr obj, IntPtr methodID, jvalue[] args){}