//
// Name
//      $RCSfile: ManagedObject.java,v $
//
// Copyright
//      Copyright 2007-2012 Cloud Software Group, Inc. ALL RIGHTS RESERVED.
//      Cloud Software Group, Inc. Confidential Information
//
// History
//      $Revision: 1.1.2.22 $ $Date: 2012/04/10 20:26:55 $
//

package com.kabira.platform;

import java.util.*;
import com.kabira.platform.annotation.*;
import java.util.concurrent.ConcurrentMap;

/**
  * Class to manipulate and find shared memory backed objects.
  * To create a Java object that persists in shared memory, see the
  * <code>&#64Managed</code> annotation.
  * <p>
  *  Example:
  *<pre>&#64Managed
public class Account {
    public Account(String userName) {
        super();
        m_userName = userName;
    }

    public Account(String userName, Account referrer) {
        this(userName);
        allocateMailbox();
        addToFriendList(referrer);
    }

    public void addToFriendList(Account friendlyAccount) {
        ...
    }

    private void allocateMailbox() {
        ...
    }

    private String m_userName;
    private Account[] m_friendList;
}</pre>
 *  Some example usage of the above type:
 <pre>
    //
    //  create a new account in shared memory:
    //
    Account newCustomer = new Account("Fred Rogers", referrer);
    System.out.println("Added " + newCustomer.toString());

    //
    //  delete all expired accounts from shared memory.
    //  Note extent access, and use of the delete() method
    //  to delete the shared memory instance.
    //
    for (Account acc : ManagedObject.extent(Account.class)) {
        if (acc.expireDate &lt; today) {
            ManagedObject.delete(acc);
        }
    }
 </pre>
 *
 *  @see com.kabira.platform.annotation.Managed
 *  @see com.kabira.platform.Transaction
 */
@Managed
public abstract class ManagedObject
{
        /**
         * Returns all shared memory instances of a Managed type.
         * <p>
         * The <code>klass</code> parameter must be a <code>Managed</code>
         * class, and is used to determine the extent to return.
         * A Managed class is either annotated <code>&#64Managed</code>, or
         * extends a class that is so annotated.
         * <p>
         * Consider the following example.  It returns all instances of
         * <code>MyType</code> (including instances of its subtypes)
         * with no locks held on the objects:
    <pre>
    //
    // Iterate instances of MyType.class, returning all objects in the extent
    //
    for (MyType instance : ManagedObject.extent(MyType.class)) {
        assert ( Transaction.hasReadLock(instance) == false );
        assert ( Transaction.hasWriteLock(instance) == false );
        ...
    }</pre>
         * @param klass extent class - instances of this type,
         * and any subtypes that extend from this type, will be returned in
         * the extent.
         * @exception ManagedClassError Thrown if <code>klass</code>
         *   is not Managed (or exactly ManagedObject).
         * @return <code>Iterable</code> that will traverse all instances 
         *   located in shared memory.
         * @see com.kabira.platform.annotation.Managed
         * @see com.kabira.platform.ManagedClassError
         */
        public static <T> java.lang.Iterable<T> extent(
                final java.lang.Class<T> klass)
                throws ManagedClassError
        {
                return ManagedObject.extent(klass, LockMode.NOLOCK);
        }

        /**
          * Returns all shared memory instances of a Managed type,
          * with an explicit transaction lock taken on each instance
          * as it is iterated.
          *<p>
          * The <code>klass</code> parameter must be a Managed class,
          * and is used to determine the extent to return.
          *<p>
          * The <code>objectLock</code> parameter is used to specify the
          * transaction lock to take on objects returned during extent 
          * iteration. The objects are locked as they are returned from the 
          * <code>java.util.Iterator<T></code>, not when this method
          * returns.
          * <p>
          * Consider the following example.  It returns all instances of
          * <code>MyType</code> (including instances of its subtypes)
          * with a READLOCK held on each instance:
         <pre>
    //
    //  Iterate the ManagedObjectSet taking read locks on the objects
    //
    for (MyType mt : ManagedObject.extent( MyType.class, LockMode.READLOCK)) {
        assert ( Transaction.hasReadLock(mt) == true );
        ...
    }</pre>
          * @param klass extent class - instances of this type,
          *   and any subtypes that extend from this type, will be returned
          *   in the extent.
          * @param objectLock object lock - all object instances
          *   returned during extent iteration will have this transaction lock.
          * @exception ManagedClassError Thrown if <code>klass</code>
          *   is not marked Managed, or is exactly ManagedObject.
          * @return <code>Iterable<klass></code> containing references to
          *   all instances located in shared memory.
          * @see com.kabira.platform.annotation.Managed
          */
        public static <T> java.lang.Iterable<T> extent(
                final java.lang.Class<T> klass,
                final LockMode objectLock)
                throws ManagedClassError
        {
                checkManagedClass(klass, "extent");

                if (klass.equals(ManagedObject.class))
                {
                        throw new ManagedClassError(
                                "extent class cannot be "
                                + ManagedObject.class.getName() + ".");
                }

                return new Extent<T>(klass.getName(), objectLock);
        }

        /** Returns a hash code based on the 
          * underlying shared memory object.
          */
        public static int hashCode(Object o)
        {
                return java.util.Arrays.hashCode(
                        ManagedObject.getObjectReference(o));
        }

        /** Returns true if both references are proxies to the same
          * shared memory object.
          *
          * @throws ManagedClassError if o1 or o2 is not Managed.
          */
        public static boolean equals(Object o1, Object o2)
                throws ManagedClassError
        {
                if (o1 == o2)
                {
                        return true;
                }

                if ((o1 == null) || (o2 == null))
                {
                        return false;
                }

                checkManagedObject(o1, "equals");
                checkManagedObject(o2, "equals");

                // FIX THIS: can we reduce two JNI calls to one?
                // FIX THIS: this is inefficient - getObjectReference is a
                // JNI native, because $m_objectReference is added at class
                // load time. This should be generated at class load time.
                return java.util.Arrays.equals(
                        ManagedObject.getObjectReference(o1),
                        ManagedObject.getObjectReference(o2));
        }

        /** Determines if the given object is an instance of a Managed class.
          * Returns true only if the object, or a superclass, is marked
          * &#64Managed.
          */
        public static boolean isManaged(Object o)
        {
                return isManagedClass(o.getClass());
        }

        /** Determines if the given class is Managed.
          * Returns true only if the class, or a superclass, is marked
          * &#64Managed.
          */
    @SuppressWarnings("deprecation")
        public static boolean isManagedClass(Class<?> klass)
        {
                return (klass.isAnnotationPresent(Managed.class)
                        || klass.isAnnotationPresent(Distributed.class));
        }

        /** If the given object is not Managed, throw a new ManagedClassError.
          */
        private static void checkManagedObject(Object o, String methodName)
                throws ManagedClassError
        {
                checkManagedClass(o.getClass(), methodName);
        }

        /** If the given class is not Managed, throw a new ManagedClassError.
          */
        private static void checkManagedClass(Class klass, String methodName)
                throws ManagedClassError
        {
                if (isManagedClass(klass) == false)
                {
                        throw new ManagedClassError("Method "
                                + methodName + "() can only be applied to "
                                + "Managed classes.");
                }
        }

        /** Return the object reference as a byte array. Package-private.
          * This may return a reference to the actual field, so the result
          * should be treated as read-only.
          * FIX THIS: inefficient to use a native for this.
          */
        static native byte[] getObjectReference(Object o);

        /** Deletes a Managed object.
          * @throws ManagedClassError if operand is not Managed.
          */
        public static void delete(Object operand)
                throws ManagedClassError
        {
                checkManagedObject(operand, "delete");
                _deleteSM(operand);
        }

        /** Returns the number of instances of the given class.
          *<br>
          * This count does not require transaction locks on the
          * extent or any of the individual objects in the extent.
          *<br>
          * This means the number returned by cardinality() may 
          * change even as observed within a single transaction.
          * @throws ManagedClassError if klass is not Managed.
          */
        public static int cardinality(Class<?> operand)
                throws ManagedClassError
        {
                checkManagedClass(operand, "cardinality");
                return ManagedObject._cardinality(operand.getName());
        }

        /** Determines if the backing shared memory object has been deleted.
          * @throws ManagedClassError if the operand object is not of a Managed
          * class.
          * @return true if the operand has been deleted, false otherwise. 
          */
        public static boolean isEmpty(Object operand)
                throws ManagedClassError
        {
                if (operand == null)
                {
                        return true;
                }
                checkManagedObject(operand, "isEmpty");
                return _isEmpty(operand);
        }
        
        /** 
         * Commit and abort triggers must be enabled in each transaction.
         * This method enables triggers for all methods in TransactionTriggers
         * (currently abort and commit).
         */
        static void enableTriggers(TransactionTriggers obj)
        {
            enableTriggers(ManagedObject.getObjectReference(obj));
        }
        native static void enableTriggers(byte[] objectReference);

        /** Determines if the passed in object reference is local
          * or distributed.
          * @returns true if the passed in reference is local
          */
        private native static boolean isLocal(byte[] objectReference);

        private native static boolean isLocalToJVM(byte[] objectReference);

        private native static boolean _isEmpty(Object operand);

        /** Creates the shared memory object.
          *
          * This method does not create shared memory for a JBA keyed type;
          * the generated JBA constructor should do that instead. 
          * This method returns the object reference as a byte array. If the
          * type was not created, a "refNULL" is returned - a byte array
          * of the appropriate size, with contents zero'ed out.
          */
        private static native byte[] createSMObject(String className);

        /**
          * Invoke post-create triggers.
          * Does not create or update keys. 
          */
        private static native void postCreateTrigger(byte[] objRef);

        /**
          * Invoke all post-create work in the runtime.
          */
        private static native void completeSMObject(
                byte[] objRef,
                boolean callTriggers);
        
    /**
          * An exception is being thrown from this constructor;
      * destroy the (partially-created) shared memory object.
          */
        private static native void cancelSMObject(byte[] objRef);

    /**
     * Set the context class loader for this thread to this classes class
     * loader.
     * NOTE this assumes the context class loader is not set. This should
     * only be called when attaching a Thread via JNI AttachCurrentThread.
     */
    private static void setContextClassLoader()
    {
        //
        // FIX THIS: The IBM JVM asserts on this, commented out for now.
        //
        // assert(Thread.currentThread().getContextClassLoader() == null);
        //
        assert(ManagedObject.class.getClassLoader() != null);

        Thread.currentThread().setContextClassLoader(
                    ManagedObject.class.getClassLoader());
    }

        private static native void _deleteSM(Object operand);

        private static native int _cardinality(String className);

    //
    // Dispatch operations
    //
        private native static Any sendTwoWay(
        final Object object,
        final int opDomainId,
        final int opTypeId,
        final AnyBuffer params);
        private native static Any sendPinnedTwoWay(
        final Object object,
        final int opDomainId,
        final int opTypeId,
        final AnyBuffer params);
        private native static void sendOneWay(
        final Object object,
        final int opDomainId,
        final int opTypeId,
        final AnyBuffer params);

    //
    // Method for Reflection support
    //
    static Object getObject(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        byte [] objRef = getObjectReference(obj);

        int slotIndex = 0;
        TypeDescriptor.FieldDescriptor slot = null;

        for (TypeDescriptor.FieldDescriptor fd : td.m_fields)
        {
            if (fd.m_name.equals(fieldName))
            {
                slot = fd;
                break;
            }
            slotIndex++;
        }
        assert( slot != null );

        //
        // We have to autobox the value based on the slot
        //
        switch (slot.m_typeId)
        {
        case TypeDescriptor.DSE_TYPEID_INT32:
            return getIntegerRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_INT64:
            return getLongRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_INT16:
            return getShortRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_WCHAR:
            return getCharacterRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_FLOAT:
            return getFloatRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_DOUBLE:
            return getDoubleRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_BOOLEAN:
            return getBooleanRef(objRef, slotIndex);
        case TypeDescriptor.DSE_TYPEID_CHAR:
        case TypeDescriptor.DSE_TYPEID_OCTET:
            return getByteRef(objRef, slotIndex);
        }

        //
        // This handles String, Date and Managed objects
        //
        return getReference(objRef, slotIndex);
    }
    static void setObject(Object obj, String fieldName, Object v)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        byte [] objRef = getObjectReference(obj);
        int slotIndex = td.getSlotIndex(fieldName);

        //
        // We have to auto-unbox the instance and call the appropriate
        // setter.
        //
        if (v instanceof Integer)
        {
            setInteger(((Integer)v).intValue(), objRef, slotIndex);
        }
        else if (v instanceof Long)
        {
            setLong(((Long)v).longValue(), objRef, slotIndex);
        }
        else if (v instanceof Short)
        {
            setShort(((Short)v).shortValue(), objRef, slotIndex);
        }
        else if (v instanceof Character)
        {
            setChar(((Character)v).charValue(), objRef, slotIndex);
        }
        else if (v instanceof Float)
        {
            setFloat(((Float)v).floatValue(), objRef, slotIndex);
        }
        else if (v instanceof Double)
        {
            setDouble(((Double)v).doubleValue(), objRef, slotIndex);
        }
        else if (v instanceof Boolean)
        {
            setBoolean(((Boolean)v).booleanValue(), objRef, slotIndex);
        }
        else if (v instanceof Byte)
        {
            setByte(((Byte)v).byteValue(), objRef, slotIndex);
        }
        else
        {
            //
            // This handles String, Date and Managed objects
            //
            setReference(v, objRef, slotIndex);
        }
    }
    static boolean getBoolean(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        Boolean b = getBooleanRef(getObjectReference(obj),
                    td.getSlotIndex(fieldName));
        return b.booleanValue();
    }
    static void setBoolean(Object obj, String fieldName, boolean b)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setBoolean(b, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static byte getByte(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        Byte v = getByteRef(getObjectReference(obj),
                    td.getSlotIndex(fieldName));
        return v.byteValue();
    }
    static void setByte(Object obj, String fieldName, byte b)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setByte(b, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static char getChar(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        Character v = getCharacterRef(getObjectReference(obj),
                    td.getSlotIndex(fieldName));
        return v.charValue();
    }
    static void setChar(Object obj, String fieldName, char c)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setChar(c, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static double getDouble(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        return getDouble(getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static void setDouble(Object obj, String fieldName, double d)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setDouble(d, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static float getFloat(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        return getFloat(getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static void setFloat(Object obj, String fieldName, float f)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setFloat(f, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static int getInt(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        return getInteger(getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static void setInt(Object obj, String fieldName, int i)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setInteger(i, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static long getLong(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        return getLong(getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static void setLong(Object obj, String fieldName, long l)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setLong(l, getObjectReference(obj), td.getSlotIndex(fieldName));
    }
    static short getShort(Object obj, String fieldName)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        Short v = getShortRef(getObjectReference(obj),
                    td.getSlotIndex(fieldName));
        return v.shortValue();
    }
    static void setShort(Object obj, String fieldName, short s)
    {
        TypeDescriptor td = TypeDescriptor.getDescriptor(obj);
        setShort(s, getObjectReference(obj), td.getSlotIndex(fieldName));
    }

        //
        // field getters/setters:
        //
        private static native Boolean getBooleanRef(
                byte[] objRef,
                long slotNum);
        private static native Byte getByteRef(
                byte[] objRef,
                long slotNum);
        private static native Character getCharacterRef(
                byte[] objRef,
                long slotNum);
        private static native Short getShortRef(
                byte[] objRef,
                long slotNum);
        private static native int getInteger(
                byte[] objRef,
                long slotNum);
        private static native Integer getIntegerRef(
                byte[] objRef,
                long slotNum);
        private static native long getLong(
                byte[] objRef,
                long slotNum);
        private static native Long getLongRef(
                byte[] objRef,
                long slotNum);
        private static native float getFloat(
                byte[] objRef,
                long slotNum);
        private static native Float getFloatRef(
                byte[] objRef,
                long slotNum);
        private static native double getDouble(
                byte[] objRef,
                long slotNum);
        private static native Double getDoubleRef(
                byte[] objRef,
                long slotNum);
        private static native Object getReference(
                byte[] objRef,
                long slotNum);
        private static Object getSerializable(
                byte[] objRef,
                long slotNum) 
        {
            Any storedval = (Any)getReference(objRef, slotNum);
            
            if (storedval == null)
            {
                return null;
            }
            
            return Any.deserializeAny(storedval);
        }

        private static native void setBoolean(
                boolean val,
                byte[] objRef,
                long slotNum);
        private static native void setBooleanRef(
                Boolean val,
                byte[] objRef,
                long slotNum);
        private static native void setByte(
                byte val,
                byte[] objRef,
                long slotNum);
        private static native void setByteRef(
                Byte val,
                byte[] objRef,
                long slotNum);
        private static native void setChar(
                char val,
                byte[] objRef,
                long slotNum);
        private static native void setCharacterRef(
                Character val,
                byte[] objRef,
                long slotNum);
        private static native void setShort(
                short val,
                byte[] objRef,
                long slotNum);
        private static native void setShortRef(
                Short val,
                byte[] objRef,
                long slotNum);
        private static native void setInteger(
                int val,
                byte[] objRef,
                long slotNum);
        private static native void setIntegerRef(
                Integer val,
                byte[] objRef,
                long slotNum);
        private static native void setLong(
                long val,
                byte[] objRef,
                long slotNum);
        private static native void setLongRef(
                Long val,
                byte[] objRef,
                long slotNum);
        private static native void setFloat(
                float val,
                byte[] objRef,
                long slotNum);
        private static native void setFloatRef(
                Float val,
                byte[] objRef,
                long slotNum);
        private static native void setDouble(
                double val,
                byte[] objRef,
                long slotNum);
        private static native void setDoubleRef(
                Double val,
                byte[] objRef,
                long slotNum);
        private static void setSerializable(
                Object val,
                byte[] objRef,
                long slotNum)
        {
            if (val == null)
            {
                setReference(null, objRef, slotNum);
            }
            else
            {
                setReference(new Any(Any.serializeObject(val)), objRef, slotNum);
            }
        }
        
        private static native void setReference(
                Object val,
                byte[] objRef,
                long slotNum);

        //
        // array-length operator:
        //
        private static native int _getArrayLength(
                byte[] objref,
                long slotNum,
                int[] coords);

        //
        // Basic-type array getters/setters:
        //
        private static native void _setByteArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                byte val);
        private static native void _setCharArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                char val);
        private static native void _setDoubleArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                double val);
        private static native void _setFloatArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                float val);
        private static native void _setIntArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                int val);
        private static native void _setLongArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                long val);
        private static native void _setShortArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                short val);

        private static native byte _getByteArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native char _getCharArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native float _getFloatArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native int _getIntArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native long _getLongArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native short _getShortArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native double _getDoubleArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);

        private static java.lang.Object _getSerializableArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos)
        {
            Object obj = _getReferenceArray(objref, slotNum, coords, pos);
            
            return Any.deserializeAny((Any)obj);
        }
        
        private static void _setSerializableArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                java.lang.Object val)
        {
            _setReferenceArray(objref, slotNum, coords, pos, new Any(Any.serializeObject(val)));
        }
        
        //
        // Reference array getters/setters:
        //
        private static native java.lang.Object _getReferenceArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos);
        private static native void _setReferenceArray(
                byte[] objref,
                long slotNum,
                int[] coords,
                int pos,
                java.lang.Object val);

        /**
         * Used for field sets of @ByReference-annotated fields. This method
         * is here in ManagedObject so we can keep it private - the classloader
         * will modify the access flags.
         */
        private static Object getByRefMap(
                Object container,
                ConcurrentMap<Object, Reference> map)
        {
            return Reference.getReference(map, container);
        }

        /**
         * Used for field sets of @ByReference-annotated fields. This method
         * is here in ManagedObject so we can keep it private - the classloader
         * will modify the access flags.
         */
        private static void setByRefMap(
                Object container,
                Object val,
                ConcurrentMap<Object, Reference> map)
        {
            Reference.setReference(map, container, val);
        }
        
        /**
         * Synthetic ByReference field maps are registered with the ReferenceManager
         * so we can scan for orphaned Reference instances.
         * This method is here so we can keep it marked private - the classloader
         * will modify the access flags.
         * Invoked by synthetic code added to static initializers.
         */
        private static void registerFieldMap(ConcurrentMap<Object, Reference> fieldMap)
        {
            Reference.registerFieldMap(fieldMap);
        }

        /** Private class returned from extent() methods (needed to use the
          * for-each loop).
          */
        private static class Extent<T>
                implements Iterable<T>
        {
                private String          m_typeName;
                private LockMode        m_objectLockMode;
                Extent(String typeName, LockMode objectLockMode)
                {
                        m_typeName = typeName;
                        m_objectLockMode = objectLockMode;
                }

                public Iterator<T> iterator()
                {
                        return new ExtentIterator<T>(
                                m_typeName,
                                m_objectLockMode);
                }
        }

        /** Class wrapping readonly access to a Managed extent.
          */
        private static class ExtentIterator<T extends Object>
                implements java.util.Iterator<T>
        {
                private LockMode        m_objectLockMode;
                private long            m_cHandle;
                private T               m_next;

                ExtentIterator(String typeName, LockMode objectLock)
                {
                        m_objectLockMode = objectLock;
                        m_cHandle = _new(typeName);
                        m_next = _next(m_cHandle);
                }

                protected void finalize()
                {
                        if (m_cHandle != 0)
                        {
                                _delete(m_cHandle);
                        }
                        m_cHandle = 0;
                }

                public boolean hasNext()
                {
                        return (m_next != null);
                }

                public T next()
                {
                        T   t = m_next;

                        m_next = _next(m_cHandle);

                        if (m_objectLockMode == LockMode.READLOCK)
                        {
                                Transaction.readLockObject(t);
                        }
                        else if (m_objectLockMode == LockMode.WRITELOCK)
                        {
                                Transaction.writeLockObject(t);
                        }
                        else
                        {
                                assert ( m_objectLockMode == LockMode.NOLOCK );
                        }

                        return t;
                }

                public void remove()
                {
                        throw new UnsupportedOperationException();
                }

                native long _new(String typeName);
                native T _next(long cHandle);
                native void _delete(long cHandle);
        }
}