Java.Lang.Object.cs

using System;
using System.Collections.Generic;
using Android.Runtime;

namespace Java.Lang {

	/// <summary>
	///   Class {@code Object} is the root of the class hierarchy.
	/// </summary>
	/// <remarks>
	///   <format type="text/html">
	///     <?xml version="1.0" encoding="utf-8"?>Class {@code Object} is the root of the class hierarchy.
	///     Every class has {@code Object} as a superclass. All objects,
	///     including arrays, implement the methods of this class.
	///     
	///     @author unascribed
	///     @see java.lang.Class
	///     @since JDK1.0
	///     @apiSince 1
	///   </format>
	/// </remarks>
	// Metadata.xml XPath class reference: path="/api/package[@name='java.lang']/class[@name='Object']"
	[global::Android.Runtime.Register ("java/lang/Object", DoNotGenerateAcw=true)]
	public partial class Object  {

		internal static IntPtr java_class_handle;
		internal static IntPtr class_ref {
			get {
				return JNIEnv.FindClass ("java/lang/Object", ref java_class_handle);
			}
		}

		static IntPtr id_ctor;
		// Metadata.xml XPath constructor reference: path="/api/package[@name='java.lang']/class[@name='Object']/constructor[@name='Object' and count(parameter)=0]"
		[Register (".ctor", "()V", "")]
		public unsafe Object ()
			: this (IntPtr.Zero, JniHandleOwnership.DoNotTransfer)
		{
			if (((global::Java.Lang.Object) this).Handle != IntPtr.Zero)
				return;

			try {
				if (((object) this).GetType () != typeof (Object)) {
					SetHandle (
							global::Android.Runtime.JNIEnv.StartCreateInstance (((object) this).GetType (), "()V"),
							JniHandleOwnership.TransferLocalRef);
					global::Android.Runtime.JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, "()V");
					return;
				}

				if (id_ctor == IntPtr.Zero)
					id_ctor = JNIEnv.GetMethodID (class_ref, "<init>", "()V");
				SetHandle (
						global::Android.Runtime.JNIEnv.StartCreateInstance (class_ref, id_ctor),
						JniHandleOwnership.TransferLocalRef);
				JNIEnv.FinishCreateInstance (((global::Java.Lang.Object) this).Handle, class_ref, id_ctor);
			} finally {
			}
		}

		static IntPtr id_getClass;
		public unsafe Java.Lang.Class Class {
			// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='getClass' and count(parameter)=0]"
			[Register ("getClass", "()Ljava/lang/Class;", "")]
			get {
				if (id_getClass == IntPtr.Zero)
					id_getClass = JNIEnv.GetMethodID (class_ref, "getClass", "()Ljava/lang/Class;");
				try {
					return global::Java.Lang.Object.GetObject<Java.Lang.Class> (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_getClass), JniHandleOwnership.TransferLocalRef);
				} finally {
				}
			}
		}

		static Delegate cb_clone;
#pragma warning disable 0169
		static Delegate GetCloneHandler ()
		{
			if (cb_clone == null)
				cb_clone = JNINativeWrapper.CreateDelegate ((_JniMarshal_PP_L) n_Clone);
			return cb_clone;
		}

		static IntPtr n_Clone (IntPtr jnienv, IntPtr native__this)
		{
			var __this = global::Java.Lang.Object.GetObject<Java.Lang.Object> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			return JNIEnv.ToLocalJniHandle (__this.Clone ());
		}
#pragma warning restore 0169

		static IntPtr id_clone;
		/// <summary>
		///   Creates and returns a copy of this object.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Creates and returns a copy of this object.  The precise meaning
		///     of &quot;copy&quot; may depend on the class of the object. The general
		///     intent is that, for any object {@code x}, the expression:
		///     <blockquote>
		///     <pre>
		///     x.clone() != x</pre></blockquote>
		///     will be true, and that the expression:
		///     <blockquote>
		///     <pre>
		///     x.clone().getClass() == x.getClass()</pre></blockquote>
		///     will be {@code true}, but these are not absolute requirements.
		///     While it is typically the case that:
		///     <blockquote>
		///     <pre>
		///     x.clone().equals(x)</pre></blockquote>
		///     will be {@code true}, this is not an absolute requirement.
		///     <p>
		///     By convention, the returned object should be obtained by calling
		///     {@code super.clone}.  If a class and all of its superclasses (except
		///     {@code Object}) obey this convention, it will be the case that
		///     {@code x.clone().getClass() == x.getClass()}.
		///     </p><p>
		///     By convention, the object returned by this method should be independent
		///     of this object (which is being cloned).  To achieve this independence,
		///     it may be necessary to modify one or more fields of the object returned
		///     by {@code super.clone} before returning it.  Typically, this means
		///     copying any mutable objects that comprise the internal &quot;deep structure&quot;
		///     of the object being cloned and replacing the references to these
		///     objects with references to the copies.  If a class contains only
		///     primitive fields or references to immutable objects, then it is usually
		///     the case that no fields in the object returned by {@code super.clone}
		///     need to be modified.
		///     </p><p>
		///     The method {@code clone} for class {@code Object} performs a
		///     specific cloning operation. First, if the class of this object does
		///     not implement the interface {@code Cloneable}, then a
		///     {@code CloneNotSupportedException} is thrown. Note that all arrays
		///     are considered to implement the interface {@code Cloneable} and that
		///     the return type of the {@code clone} method of an array type {@code T[]}
		///     is {@code T[]} where T is any reference or primitive type.
		///     Otherwise, this method creates a new instance of the class of this
		///     object and initializes all its fields with exactly the contents of
		///     the corresponding fields of this object, as if by assignment; the
		///     contents of the fields are not themselves cloned. Thus, this method
		///     performs a &quot;shallow copy&quot; of this object, not a &quot;deep copy&quot; operation.
		///     </p><p>
		///     The class {@code Object} does not itself implement the interface
		///     {@code Cloneable}, so calling the {@code clone} method on an object
		///     whose class is {@code Object} will result in throwing an
		///     exception at run time.
		///     
		///     @return a clone of this instance.
		///     @throws CloneNotSupportedException if the object's class does not
		///                   support the {@code Cloneable} interface. Subclasses
		///                   that override the {@code clone} method can also
		///                   throw this exception to indicate that an instance cannot
		///                   be cloned.
		///     @see java.lang.Cloneable
		///     @apiSince 1</p></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='clone' and count(parameter)=0]"
		[Register ("clone", "()Ljava/lang/Object;", "GetCloneHandler")]
		protected virtual unsafe Java.Lang.Object Clone ()
		{
			if (id_clone == IntPtr.Zero)
				id_clone = JNIEnv.GetMethodID (class_ref, "clone", "()Ljava/lang/Object;");
			try {

				if (((object) this).GetType () == ThresholdType)
					return global::Java.Lang.Object.GetObject<Java.Lang.Object> (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_clone), JniHandleOwnership.TransferLocalRef);
				else
					return global::Java.Lang.Object.GetObject<Java.Lang.Object> (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "clone", "()Ljava/lang/Object;")), JniHandleOwnership.TransferLocalRef);
			} finally {
			}
		}

		static Delegate cb_equals_Ljava_lang_Object_;
#pragma warning disable 0169
		static Delegate GetEquals_Ljava_lang_Object_Handler ()
		{
			if (cb_equals_Ljava_lang_Object_ == null)
				cb_equals_Ljava_lang_Object_ = JNINativeWrapper.CreateDelegate ((_JniMarshal_PPL_Z) n_Equals_Ljava_lang_Object_);
			return cb_equals_Ljava_lang_Object_;
		}

		static bool n_Equals_Ljava_lang_Object_ (IntPtr jnienv, IntPtr native__this, IntPtr native_obj)
		{
			var __this = global::Java.Lang.Object.GetObject<Java.Lang.Object> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			var obj = global::Java.Lang.Object.GetObject<Java.Lang.Object> (native_obj, JniHandleOwnership.DoNotTransfer);
			bool __ret = __this.Equals (obj);
			return __ret;
		}
#pragma warning restore 0169

		static IntPtr id_equals_Ljava_lang_Object_;
		/// <summary>
		///   Indicates whether some other object is "equal to" this one.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Indicates whether some other object is &quot;equal to&quot; this one.
		///     <p>
		///     The {@code equals} method implements an equivalence relation
		///     on non-null object references:
		///     </p><ul>
		///     <li>It is <i>reflexive</i>: for any non-null reference value
		///         {@code x}, {@code x.equals(x)} should return
		///         {@code true}.
		///     </li><li>It is <i>symmetric</i>: for any non-null reference values
		///         {@code x} and {@code y}, {@code x.equals(y)}
		///         should return {@code true} if and only if
		///         {@code y.equals(x)} returns {@code true}.
		///     </li><li>It is <i>transitive</i>: for any non-null reference values
		///         {@code x}, {@code y}, and {@code z}, if
		///         {@code x.equals(y)} returns {@code true} and
		///         {@code y.equals(z)} returns {@code true}, then
		///         {@code x.equals(z)} should return {@code true}.
		///     </li><li>It is <i>consistent</i>: for any non-null reference values
		///         {@code x} and {@code y}, multiple invocations of
		///         {@code x.equals(y)} consistently return {@code true}
		///         or consistently return {@code false}, provided no
		///         information used in {@code equals} comparisons on the
		///         objects is modified.
		///     </li><li>For any non-null reference value {@code x},
		///         {@code x.equals(null)} should return {@code false}.
		///     
		///     <p>
		///     The {@code equals} method for class {@code Object} implements
		///     the most discriminating possible equivalence relation on objects;
		///     that is, for any non-null reference values {@code x} and
		///     {@code y}, this method returns {@code true} if and only
		///     if {@code x} and {@code y} refer to the same object
		///     ({@code x == y} has the value {@code true}).
		///     </p><p>
		///     Note that it is generally necessary to override the {@code hashCode}
		///     method whenever this method is overridden, so as to maintain the
		///     general contract for the {@code hashCode} method, which states
		///     that equal objects must have equal hash codes.
		///     
		///     @param obj the reference object with which to compare.
		///     @return {@code true} if this object is the same as the obj
		///              argument; {@code false} otherwise.
		///     @see #hashCode()
		///     @see java.util.HashMap
		///     @apiSince 1</p></li></ul></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='equals' and count(parameter)=1 and parameter[1][@type='java.lang.Object']]"
		[Register ("equals", "(Ljava/lang/Object;)Z", "GetEquals_Ljava_lang_Object_Handler")]
		public virtual unsafe bool Equals (Java.Lang.Object obj)
		{
			if (id_equals_Ljava_lang_Object_ == IntPtr.Zero)
				id_equals_Ljava_lang_Object_ = JNIEnv.GetMethodID (class_ref, "equals", "(Ljava/lang/Object;)Z");
			try {
				JValue* __args = stackalloc JValue [1];
				__args [0] = new JValue (obj);

				bool __ret;
				if (((object) this).GetType () == ThresholdType)
					__ret = JNIEnv.CallBooleanMethod (((global::Java.Lang.Object) this).Handle, id_equals_Ljava_lang_Object_, __args);
				else
					__ret = JNIEnv.CallNonvirtualBooleanMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "equals", "(Ljava/lang/Object;)Z"), __args);
				return __ret;
			} finally {
			}
		}

		static Delegate cb_finalize;
#pragma warning disable 0169
		static Delegate GetFinalizeHandler ()
		{
			if (cb_finalize == null)
				cb_finalize = JNINativeWrapper.CreateDelegate ((_JniMarshal_PP_V) n_Finalize);
			return cb_finalize;
		}

		static void n_Finalize (IntPtr jnienv, IntPtr native__this)
		{
			var __this = global::Java.Lang.Object.GetObject<Java.Lang.Object> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			__this.Finalize ();
		}
#pragma warning restore 0169

		static IntPtr id_finalize;
		/// <summary>
		///   Called by the garbage collector on an object when garbage collection
		///   determines that there are no more references to the object.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Called by the garbage collector on an object when garbage collection
		///     determines that there are no more references to the object.
		///     A subclass overrides the {@code finalize} method to dispose of
		///     system resources or to perform other cleanup.
		///     <p>
		///     The general contract of {@code finalize} is that it is invoked
		///     if and when the Java&amp;trade; virtual
		///     machine has determined that there is no longer any
		///     means by which this object can be accessed by any thread that has
		///     not yet died, except as a result of an action taken by the
		///     finalization of some other object or class which is ready to be
		///     finalized. The {@code finalize} method may take any action, including
		///     making this object available again to other threads; the usual purpose
		///     of {@code finalize}, however, is to perform cleanup actions before
		///     the object is irrevocably discarded. For example, the finalize method
		///     for an object that represents an input/output connection might perform
		///     explicit I/O transactions to break the connection before the object is
		///     permanently discarded.
		///     </p><p>
		///     The {@code finalize} method of class {@code Object} performs no
		///     special action; it simply returns normally. Subclasses of
		///     {@code Object} may override this definition.
		///     </p><p>
		///     The Java programming language does not guarantee which thread will
		///     invoke the {@code finalize} method for any given object. It is
		///     guaranteed, however, that the thread that invokes finalize will not
		///     be holding any user-visible synchronization locks when finalize is
		///     invoked. If an uncaught exception is thrown by the finalize method,
		///     the exception is ignored and finalization of that object terminates.
		///     </p><p>
		///     After the {@code finalize} method has been invoked for an object, no
		///     further action is taken until the Java virtual machine has again
		///     determined that there is no longer any means by which this object can
		///     be accessed by any thread that has not yet died, including possible
		///     actions by other objects or classes which are ready to be finalized,
		///     at which point the object may be discarded.
		///     </p><p>
		///     The {@code finalize} method is never invoked more than once by a Java
		///     virtual machine for any given object.
		///     </p><p>
		///     Any exception thrown by the {@code finalize} method causes
		///     the finalization of this object to be halted, but is otherwise
		///     ignored.
		///     
		///     @throws Throwable the {@code Exception} raised by this method
		///     @see java.lang.ref.WeakReference
		///     @see java.lang.ref.PhantomReference
		///     @jls 12.6 Finalization of Class Instances
		///     @apiSince 1</p></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='finalize' and count(parameter)=0]"
		[Register ("finalize", "()V", "GetFinalizeHandler")]
		protected virtual unsafe void Finalize ()
		{
			if (id_finalize == IntPtr.Zero)
				id_finalize = JNIEnv.GetMethodID (class_ref, "finalize", "()V");
			try {

				if (((object) this).GetType () == ThresholdType)
					JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_finalize);
				else
					JNIEnv.CallNonvirtualVoidMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "finalize", "()V"));
			} finally {
			}
		}

		static Delegate cb_hashCode;
#pragma warning disable 0169
		static Delegate GetGetHashCodeHandler ()
		{
			if (cb_hashCode == null)
				cb_hashCode = JNINativeWrapper.CreateDelegate ((_JniMarshal_PP_I) n_GetHashCode);
			return cb_hashCode;
		}

		static int n_GetHashCode (IntPtr jnienv, IntPtr native__this)
		{
			var __this = global::Java.Lang.Object.GetObject<Java.Lang.Object> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			return __this.GetHashCode ();
		}
#pragma warning restore 0169

		static IntPtr id_hashCode;
		/// <summary>
		///   Returns a hash code value for the object.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Returns a hash code value for the object. This method is
		///     supported for the benefit of hash tables such as those provided by
		///     {@link java.util.HashMap}.
		///     <p>
		///     The general contract of {@code hashCode} is:
		///     </p><ul>
		///     <li>Whenever it is invoked on the same object more than once during
		///         an execution of a Java application, the {@code hashCode} method
		///         must consistently return the same integer, provided no information
		///         used in {@code equals} comparisons on the object is modified.
		///         This integer need not remain consistent from one execution of an
		///         application to another execution of the same application.
		///     </li><li>If two objects are equal according to the {@code equals(Object)}
		///         method, then calling the {@code hashCode} method on each of
		///         the two objects must produce the same integer result.
		///     </li><li>It is <em>not</em> required that if two objects are unequal
		///         according to the {@link java.lang.Object#equals(java.lang.Object)}
		///         method, then calling the {@code hashCode} method on each of the
		///         two objects must produce distinct integer results.  However, the
		///         programmer should be aware that producing distinct integer results
		///         for unequal objects may improve the performance of hash tables.
		///     
		///     <p>
		///     As much as is reasonably practical, the hashCode method defined by
		///     class {@code Object} does return distinct integers for distinct
		///     objects. (This is typically implemented by converting the internal
		///     address of the object into an integer, but this implementation
		///     technique is not required by the
		///     Java&amp;trade; programming language.)
		///     
		///     @return a hash code value for this object.
		///     @see java.lang.Object#equals(java.lang.Object)
		///     @see java.lang.System#identityHashCode
		///     @apiSince 1</p></li></ul></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='hashCode' and count(parameter)=0]"
		[Register ("hashCode", "()I", "GetGetHashCodeHandler")]
		public override unsafe int GetHashCode ()
		{
			if (id_hashCode == IntPtr.Zero)
				id_hashCode = JNIEnv.GetMethodID (class_ref, "hashCode", "()I");
			try {

				if (((object) this).GetType () == ThresholdType)
					return JNIEnv.CallIntMethod (((global::Java.Lang.Object) this).Handle, id_hashCode);
				else
					return JNIEnv.CallNonvirtualIntMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "hashCode", "()I"));
			} finally {
			}
		}

		static IntPtr id_notify;
		/// <summary>
		///   Wakes up a single thread that is waiting on this object's
		///   monitor.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Wakes up a single thread that is waiting on this object's
		///     monitor. If any threads are waiting on this object, one of them
		///     is chosen to be awakened. The choice is arbitrary and occurs at
		///     the discretion of the implementation. A thread waits on an object's
		///     monitor by calling one of the {@code wait} methods.
		///     <p>
		///     The awakened thread will not be able to proceed until the current
		///     thread relinquishes the lock on this object. The awakened thread will
		///     compete in the usual manner with any other threads that might be
		///     actively competing to synchronize on this object; for example, the
		///     awakened thread enjoys no reliable privilege or disadvantage in being
		///     the next thread to lock this object.
		///     </p><p>
		///     This method should only be called by a thread that is the owner
		///     of this object's monitor. A thread becomes the owner of the
		///     object's monitor in one of three ways:
		///     </p><ul>
		///     <li>By executing a synchronized instance method of that object.
		///     </li><li>By executing the body of a {@code synchronized} statement
		///         that synchronizes on the object.
		///     </li><li>For objects of type {@code Class,} by executing a
		///         synchronized static method of that class.
		///     
		///     <p>
		///     Only one thread at a time can own an object's monitor.
		///     
		///     @throws IllegalMonitorStateException if the current thread is not
		///                   the owner of this object's monitor.
		///     @see java.lang.Object#notifyAll()
		///     @see java.lang.Object#wait()
		///     @apiSince 1</p></li></ul></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='notify' and count(parameter)=0]"
		[Register ("notify", "()V", "")]
		public unsafe void Notify ()
		{
			if (id_notify == IntPtr.Zero)
				id_notify = JNIEnv.GetMethodID (class_ref, "notify", "()V");
			try {
				JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_notify);
			} finally {
			}
		}

		static IntPtr id_notifyAll;
		/// <summary>
		///   Wakes up all threads that are waiting on this object's monitor.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Wakes up all threads that are waiting on this object's monitor. A
		///     thread waits on an object's monitor by calling one of the
		///     {@code wait} methods.
		///     <p>
		///     The awakened threads will not be able to proceed until the current
		///     thread relinquishes the lock on this object. The awakened threads
		///     will compete in the usual manner with any other threads that might
		///     be actively competing to synchronize on this object; for example,
		///     the awakened threads enjoy no reliable privilege or disadvantage in
		///     being the next thread to lock this object.
		///     </p><p>
		///     This method should only be called by a thread that is the owner
		///     of this object's monitor. See the {@code notify} method for a
		///     description of the ways in which a thread can become the owner of
		///     a monitor.
		///     
		///     @throws IllegalMonitorStateException if the current thread is not
		///                   the owner of this object's monitor.
		///     @see java.lang.Object#notify()
		///     @see java.lang.Object#wait()
		///     @apiSince 1</p></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='notifyAll' and count(parameter)=0]"
		[Register ("notifyAll", "()V", "")]
		public unsafe void NotifyAll ()
		{
			if (id_notifyAll == IntPtr.Zero)
				id_notifyAll = JNIEnv.GetMethodID (class_ref, "notifyAll", "()V");
			try {
				JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_notifyAll);
			} finally {
			}
		}

		static Delegate cb_toString;
#pragma warning disable 0169
		static Delegate GetToStringHandler ()
		{
			if (cb_toString == null)
				cb_toString = JNINativeWrapper.CreateDelegate ((_JniMarshal_PP_L) n_ToString);
			return cb_toString;
		}

		static IntPtr n_ToString (IntPtr jnienv, IntPtr native__this)
		{
			var __this = global::Java.Lang.Object.GetObject<Java.Lang.Object> (jnienv, native__this, JniHandleOwnership.DoNotTransfer);
			return JNIEnv.NewString (__this.ToString ());
		}
#pragma warning restore 0169

		static IntPtr id_toString;
		/// <summary>
		///   Returns a string representation of the object.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Returns a string representation of the object. In general, the
		///     {@code toString} method returns a string that
		///     &quot;textually represents&quot; this object. The result should
		///     be a concise but informative representation that is easy for a
		///     person to read.
		///     It is recommended that all subclasses override this method.
		///     <p>
		///     The {@code toString} method for class {@code Object}
		///     returns a string consisting of the name of the class of which the
		///     object is an instance, the at-sign character `{@code @}', and
		///     the unsigned hexadecimal representation of the hash code of the
		///     object. In other words, this method returns a string equal to the
		///     value of:
		///     </p><blockquote>
		///     <pre>
		///     getClass().getName() + '@' + Integer.toHexString(hashCode())
		///     </pre></blockquote>
		///     
		///     @return a string representation of the object.
		///     @apiSince 1</span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='toString' and count(parameter)=0]"
		[Register ("toString", "()Ljava/lang/String;", "GetToStringHandler")]
		public override unsafe string ToString ()
		{
			if (id_toString == IntPtr.Zero)
				id_toString = JNIEnv.GetMethodID (class_ref, "toString", "()Ljava/lang/String;");
			try {

				if (((object) this).GetType () == ThresholdType)
					return JNIEnv.GetString (JNIEnv.CallObjectMethod (((global::Java.Lang.Object) this).Handle, id_toString), JniHandleOwnership.TransferLocalRef);
				else
					return JNIEnv.GetString (JNIEnv.CallNonvirtualObjectMethod (((global::Java.Lang.Object) this).Handle, ThresholdClass, JNIEnv.GetMethodID (ThresholdClass, "toString", "()Ljava/lang/String;")), JniHandleOwnership.TransferLocalRef);
			} finally {
			}
		}

		static IntPtr id_wait;
		/// <summary>
		///   Causes the current thread to wait until another thread invokes the
		///   {@link java.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Causes the current thread to wait until another thread invokes the
		///     {@link java.lang.Object#notify()} method or the
		///     {@link java.lang.Object#notifyAll()} method for this object.
		///     In other words, this method behaves exactly as if it simply
		///     performs the call {@code wait(0)}.
		///     <p>
		///     The current thread must own this object's monitor. The thread
		///     releases ownership of this monitor and waits until another thread
		///     notifies threads waiting on this object's monitor to wake up
		///     either through a call to the {@code notify} method or the
		///     {@code notifyAll} method. The thread then waits until it can
		///     re-obtain ownership of the monitor and resumes execution.
		///     </p><p>
		///     As in the one argument version, interrupts and spurious wakeups are
		///     possible, and this method should always be used in a loop:
		///     </p><pre>
		///         synchronized (obj) {
		///             while (&lt;condition does not hold&gt;)
		///                 obj.wait();
		///             ... // Perform action appropriate to condition
		///         }
		///     </pre>
		///     This method should only be called by a thread that is the owner
		///     of this object's monitor. See the {@code notify} method for a
		///     description of the ways in which a thread can become the owner of
		///     a monitor.
		///     
		///     @throws IllegalMonitorStateException if the current thread is not
		///                   the owner of the object's monitor.
		///     @throws InterruptedException if any thread interrupted the
		///                 current thread before or while the current thread
		///                 was waiting for a notification.  The <i>interrupted
		///                 status</i> of the current thread is cleared when
		///                 this exception is thrown.
		///     @see java.lang.Object#notify()
		///     @see java.lang.Object#notifyAll()
		///     @apiSince 1</span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='wait' and count(parameter)=0]"
		[Register ("wait", "()V", "")]
		public unsafe void Wait ()
		{
			if (id_wait == IntPtr.Zero)
				id_wait = JNIEnv.GetMethodID (class_ref, "wait", "()V");
			try {
				JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_wait);
			} finally {
			}
		}

		static IntPtr id_wait_J;
		/// <summary>
		///   Causes the current thread to wait until either another thread invokes the
		///   {@link java.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Causes the current thread to wait until either another thread invokes the
		///     {@link java.lang.Object#notify()} method or the
		///     {@link java.lang.Object#notifyAll()} method for this object, or a
		///     specified amount of time has elapsed.
		///     <p>
		///     The current thread must own this object's monitor.
		///     </p><p>
		///     This method causes the current thread (call it <var>T</var>) to
		///     place itself in the wait set for this object and then to relinquish
		///     any and all synchronization claims on this object. Thread <var>T</var>
		///     becomes disabled for thread scheduling purposes and lies dormant
		///     until one of four things happens:
		///     </p><ul>
		///     <li>Some other thread invokes the {@code notify} method for this
		///     object and thread <var>T</var> happens to be arbitrarily chosen as
		///     the thread to be awakened.
		///     </li><li>Some other thread invokes the {@code notifyAll} method for this
		///     object.
		///     </li><li>Some other thread {@linkplain Thread#interrupt() interrupts}
		///     thread <var>T</var>.
		///     </li><li>The specified amount of real time has elapsed, more or less.  If
		///     {@code timeout} is zero, however, then real time is not taken into
		///     consideration and the thread simply waits until notified.
		///     
		///     The thread <var>T</var> is then removed from the wait set for this
		///     object and re-enabled for thread scheduling. It then competes in the
		///     usual manner with other threads for the right to synchronize on the
		///     object; once it has gained control of the object, all its
		///     synchronization claims on the object are restored to the status quo
		///     ante - that is, to the situation as of the time that the {@code wait}
		///     method was invoked. Thread <var>T</var> then returns from the
		///     invocation of the {@code wait} method. Thus, on return from the
		///     {@code wait} method, the synchronization state of the object and of
		///     thread {@code T} is exactly as it was when the {@code wait} method
		///     was invoked.
		///     <p>
		///     A thread can also wake up without being notified, interrupted, or
		///     timing out, a so-called <i>spurious wakeup</i>.  While this will rarely
		///     occur in practice, applications must guard against it by testing for
		///     the condition that should have caused the thread to be awakened, and
		///     continuing to wait if the condition is not satisfied.  In other words,
		///     waits should always occur in loops, like this one:
		///     </p><pre>
		///         synchronized (obj) {
		///             while (&lt;condition does not hold&gt;)
		///                 obj.wait(timeout);
		///             ... // Perform action appropriate to condition
		///         }
		///     </pre>
		///     (For more information on this topic, see Section 3.2.3 in Doug Lea's
		///     &quot;Concurrent Programming in Java (Second Edition)&quot; (Addison-Wesley,
		///     2000), or Item 50 in Joshua Bloch's &quot;Effective Java Programming
		///     Language Guide&quot; (Addison-Wesley, 2001).
		///     
		///     <p>If the current thread is {@linkplain java.lang.Thread#interrupt()
		///     interrupted} by any thread before or while it is waiting, then an
		///     {@code InterruptedException} is thrown.  This exception is not
		///     thrown until the lock status of this object has been restored as
		///     described above.
		///     
		///     </p><p>
		///     Note that the {@code wait} method, as it places the current thread
		///     into the wait set for this object, unlocks only this object; any
		///     other objects on which the current thread may be synchronized remain
		///     locked while the thread waits.
		///     </p><p>
		///     This method should only be called by a thread that is the owner
		///     of this object's monitor. See the {@code notify} method for a
		///     description of the ways in which a thread can become the owner of
		///     a monitor.
		///     
		///     @param timeout the maximum time to wait in milliseconds.
		///     @throws IllegalArgumentException if the value of timeout is
		///                   negative.
		///     @throws IllegalMonitorStateException if the current thread is not
		///                   the owner of the object's monitor.
		///     @throws InterruptedException if any thread interrupted the
		///                 current thread before or while the current thread
		///                 was waiting for a notification.  The <i>interrupted
		///                 status</i> of the current thread is cleared when
		///                 this exception is thrown.
		///     @see java.lang.Object#notify()
		///     @see java.lang.Object#notifyAll()
		///     @apiSince 1</p></li></ul></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='wait' and count(parameter)=1 and parameter[1][@type='long']]"
		[Register ("wait", "(J)V", "")]
		public unsafe void Wait (long timeout)
		{
			if (id_wait_J == IntPtr.Zero)
				id_wait_J = JNIEnv.GetMethodID (class_ref, "wait", "(J)V");
			try {
				JValue* __args = stackalloc JValue [1];
				__args [0] = new JValue (timeout);
				JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_wait_J, __args);
			} finally {
			}
		}

		static IntPtr id_wait_JI;
		/// <summary>
		///   Causes the current thread to wait until another thread invokes the
		///   {@link java.
		/// </summary>
		/// <remarks>
		///   <format type="text/html">
		///     <?xml version="1.0" encoding="utf-8"?><span>Causes the current thread to wait until another thread invokes the
		///     {@link java.lang.Object#notify()} method or the
		///     {@link java.lang.Object#notifyAll()} method for this object, or
		///     some other thread interrupts the current thread, or a certain
		///     amount of real time has elapsed.
		///     <p>
		///     This method is similar to the {@code wait} method of one
		///     argument, but it allows finer control over the amount of time to
		///     wait for a notification before giving up. The amount of real time,
		///     measured in nanoseconds, is given by:
		///     </p><blockquote>
		///     <pre>
		///     1000000*timeout+nanos</pre></blockquote>
		///     <p>
		///     In all other respects, this method does the same thing as the
		///     method {@link #wait(long)} of one argument. In particular,
		///     {@code wait(0, 0)} means the same thing as {@code wait(0)}.
		///     </p><p>
		///     The current thread must own this object's monitor. The thread
		///     releases ownership of this monitor and waits until either of the
		///     following two conditions has occurred:
		///     </p><ul>
		///     <li>Another thread notifies threads waiting on this object's monitor
		///         to wake up either through a call to the {@code notify} method
		///         or the {@code notifyAll} method.
		///     </li><li>The timeout period, specified by {@code timeout}
		///         milliseconds plus {@code nanos} nanoseconds arguments, has
		///         elapsed.
		///     
		///     <p>
		///     The thread then waits until it can re-obtain ownership of the
		///     monitor and resumes execution.
		///     </p><p>
		///     As in the one argument version, interrupts and spurious wakeups are
		///     possible, and this method should always be used in a loop:
		///     </p><pre>
		///         synchronized (obj) {
		///             while (&lt;condition does not hold&gt;)
		///                 obj.wait(timeout, nanos);
		///             ... // Perform action appropriate to condition
		///         }
		///     </pre>
		///     This method should only be called by a thread that is the owner
		///     of this object's monitor. See the {@code notify} method for a
		///     description of the ways in which a thread can become the owner of
		///     a monitor.
		///     
		///     @param timeout the maximum time to wait in milliseconds.
		///     @param nanos additional time, in nanoseconds range
		///                           0-999999.
		///     @throws IllegalArgumentException if the value of timeout is
		///                          negative or the value of nanos is
		///                          not in the range 0-999999.
		///     @throws IllegalMonitorStateException if the current thread is not
		///                   the owner of this object's monitor.
		///     @throws InterruptedException if any thread interrupted the
		///                 current thread before or while the current thread
		///                 was waiting for a notification.  The <i>interrupted
		///                 status</i> of the current thread is cleared when
		///                 this exception is thrown.
		///     @apiSince 1</li></ul></span>
		///   </format>
		/// </remarks>
		// Metadata.xml XPath method reference: path="/api/package[@name='java.lang']/class[@name='Object']/method[@name='wait' and count(parameter)=2 and parameter[1][@type='long'] and parameter[2][@type='int']]"
		[Register ("wait", "(JI)V", "")]
		public unsafe void Wait (long timeout, int nanos)
		{
			if (id_wait_JI == IntPtr.Zero)
				id_wait_JI = JNIEnv.GetMethodID (class_ref, "wait", "(JI)V");
			try {
				JValue* __args = stackalloc JValue [2];
				__args [0] = new JValue (timeout);
				__args [1] = new JValue (nanos);
				JNIEnv.CallVoidMethod (((global::Java.Lang.Object) this).Handle, id_wait_JI, __args);
			} finally {
			}
		}

	}
}