Object.java

package java.lang;

import lejos.nxt.VM;

/**
 * All classes extend this one, implicitly.
 */
public class Object
{
    /**
     * Creates a shallow copy of the supplied Object
     * @param old Object to clone
     * @return A shallow copy of the Object
     */
    private static final native Object cloneObject(Object old);

    /**
     * Create a copy of this object, using a shallow copy.
     * @return The new copy of the Object
     * @throws java.lang.CloneNotSupportedException
     */
	protected Object clone() throws CloneNotSupportedException
	{
		if (this instanceof Cloneable)
        	return cloneObject(this);

		throw new CloneNotSupportedException();
	}
	
	public boolean equals (Object aOther)
	{
		return this == aOther;
	}
	
	/**
	 * @deprecated not implemented in leJOS 
	 */
	@Deprecated
	protected void finalize()
	{
		//nothing
	}

	/**
	 *Returns <code>null</code>. It's here to satisfy javac.
	 */
	public final Class<?> getClass()
	{
        // The compiler seems to gnerate calls to this method that do not use the
        // return value. So for now to avoid breaking code we simply return null.
		//throw new UnsupportedOperationException();
        return VM.getVM().getClass(this);
	}

	public int hashCode()
	{
		return System.identityHashCode(this);
	}

	/**
	 * Wake up one thread blocked on a wait(). Must be synchronized on
	 * this object otherwise an IllegalMonitorStateException will be thrown.
	 * <P>
	 * If multiple threads are waiting, higher priority threads will be woken
	 * in preference, otherwise the thread that gets woken is essentially
	 * random. 
	 */
	public final native void notify();
	
	/**
	 * Wake up all threads blocked on a wait(). Must be synchronized on
	 * this object otherwise an IllegalMonitorStateException will be thrown.
	 */
	public final native void notifyAll();
	
	public String toString()
	{
		int hash = System.identityHashCode(this);
		return "Object@"+Integer.toHexString(hash);
	}
	
	/**
	 * This is the same as calling wait(0).
	 * TODO make this a Java method that calls wait(0) since native methods are expensive?
	 */
	public final native void wait() throws InterruptedException;
	
	/**
	 * Wait until notified. Must be synchronized on this object otherwise
	 * an IllegalMonitorStateException will be thrown. The wait can
	 * terminate if one of the following things occurs:
	 * <ol>
	 * <li>notify() or notifyAll() is called.
	 * <li>The calling thread is interrupted.
	 * <li>The timeout expires.
	 * </ol>
	 * @param timeout maximum time in milliseconds to wait. Zero means forever.
	 */
	public final native void wait(long timeout) throws InterruptedException;
	
	public final void wait(long timeout, int nanos) throws InterruptedException
	{
		//rounding up
		if (nanos > 0)
			timeout++;
		
		this.wait(timeout);
	}
}