GenClassImpl.java

/*
 * JOnAS: Java(TM) Open Application Server
 * Copyright (C) 1999 Bull S.A.
 * Contact: jonas-team@objectweb.org
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
 * USA
 *
 * Initial developer(s): Sebastien Chassande
 * Contributor(s):
 *
 * --------------------------------------------------------------------------
 * $Id: GenClassImpl.java,v 1.23 2004/09/06 14:42:24 joaninh Exp $
 * --------------------------------------------------------------------------
 */
package org.objectweb.jonas_ejb.container.jorm;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.NoSuchElementException;
import javax.ejb.EJBException;
import org.objectweb.jonas_ejb.container.JEntityFactory;
import org.objectweb.jonas_ejb.container.TraceEjb;
import org.objectweb.jorm.api.PBinding;
import org.objectweb.jorm.api.PClassMapping;
import org.objectweb.jorm.api.PException;
import org.objectweb.jorm.api.PExceptionProtocol;
import org.objectweb.jorm.api.PGenClassAccessor;
import org.objectweb.jorm.api.PIndexedElem;
import org.objectweb.jorm.naming.api.PBinder;
import org.objectweb.jorm.naming.api.PName;
import org.objectweb.jorm.naming.api.PNameManager;
import org.objectweb.jorm.naming.api.PExceptionNaming;
import org.objectweb.util.monolog.api.BasicLevel;


public abstract class GenClassImpl implements PGenClassAccessor {

    protected ArrayList pIndexedElems = null;

    protected int[] deletedLength = null;

    protected int size;

    protected boolean isModified = false;

    protected PClassMapping gcm = null;

    protected PBinding pb = null;

    protected GenClassListener listener = null;

    public GenClassImpl(PClassMapping gcm) {
        this();
        this.gcm = gcm;
    }

    public GenClassImpl() {
        pIndexedElems = new ArrayList(0);
        size = 0;
        deletedLength = new int[0];
        isModified = false;
    }

    public void setPClassMapping(PClassMapping gcm) {
        this.gcm = gcm;
    }

    public void reset() {
        pIndexedElems.clear();
        size = 0;
        deletedLength = new int[0];
        isModified = false;
    }

    public void setPBinding(PBinding pb) {
        this.pb = pb;
    }

    public PBinding gcGetPBinding() {
        return pb;
    }

    public void setListener(GenClassListener gcl) {
        listener = gcl;
    }

    public GenClassListener getListener() {
        return listener;
    }

    // IMPLEMENTATION OF THE Persitence lyfe cycle //
    //---------------------------------------------//

    public boolean gcIsModified() {
        return isModified;
    }

    public void read(PName pn, Object connection) throws PException {
        TraceEjb.genclass.log(BasicLevel.DEBUG, "PName=" + pn);
        if (pn == null || pn.isNull()) {
            reset();
            return;
        }
        if (pb == null) {
            throw new PExceptionProtocol("Impossible to read a persitent object withoout PBinding");
        }
        // Allocate a connection if needed
        Object conn = (connection == null
                       ? gcm.getPMapper().getConnection()
                       : connection);
        TraceEjb.genclass.log(BasicLevel.DEBUG, "Load the genclass");
        pb.bind(pn);
        pb.read(conn, this);
        pb.unbind();
        isModified = false;

        // close the connection opened localy
        if (connection == null) {
            gcm.getPMapper().closeConnection(conn);
        }
    }

    public void write(PName pn, Object connection) throws PException {
        TraceEjb.genclass.log(BasicLevel.DEBUG, "");
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "begin"); printState();
        if (pn == null || pn.isNull()) {
            throw new PExceptionProtocol("Impossible to write a persitent object with a null PName: " + pn);
        }
        if (isModified) {
            // Allocate a connection if needed
            Object conn = (connection == null
                           ? gcm.getPMapper().getConnection()
                           : connection);

            if (pb == null) {
                throw new PExceptionProtocol("Impossible to write a persitent object without PBinding");
            }
            TraceEjb.genclass.log(BasicLevel.DEBUG, "Store the genclass " + pn);
            pb.bind(pn);
            pb.write(conn, this);
            pb.unbind();

            // The data are written on the support, then the memory instance is
            // up to date. The element marked as removed must really be removed
            // from the list.
            isModified = false;
            int pos = 0;
            for (int i = 0; i < deletedLength.length; i++) {
                pos += deletedLength[i];
                pIndexedElems.remove(pos);
            }
            deletedLength = new int[0];
            for (Iterator it = pIndexedElems.iterator(); it.hasNext();) {
                GenClassElement gce = (GenClassElement) it.next();
                gce.status = PIndexedElem.ELEM_UNMODIFIED;
                gce.hasBeenCreated = false;
            }

            // close the connection opened localy
            if (connection == null) {
                gcm.getPMapper().closeConnection(conn);
            }
        }
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "end"); printState();
    }

    public void doNotWrite(PObject po) {
        GenClassElement gce = null;
        for (Iterator it = pIndexedElems.iterator(); it.hasNext() && gce == null;) {
            gce = (GenClassElement) it.next();
            if (gce.value != null) {
                if (po == gce.value) {
                    break;
                }
            } else if (gce.pname != null && gce.pname.equals(po.getPName())) {
                break;
            }
            gce = null;
        }
        if (gce == null) {
            throw new EJBException("Impossible to mark the element as written "
                                   + "because it does not  be found in the GenClass: "
                                   + po.getPName());
        }
        if (TraceEjb.genclass.isLoggable(BasicLevel.DEBUG)) {
            TraceEjb.genclass.log(BasicLevel.DEBUG,
                                  "assign ELEM_UNMODIFIED to " + po.getPName());
        }
        gce.status = PIndexedElem.ELEM_UNMODIFIED;
    }

    // IMPLEMENTATION OF THE PAccessor INTERFACE //
    //-------------------------------------------//

    public Object getMemoryInstance() {
        return this;
    }


    // IMPLEMENTATION OF THE PGenClassAccessor INTERFACE //
    //---------------------------------------------------//

    public void paAdd(PIndexedElem elem, Object conn) throws PException {
        pIndexedElems.add(elem);
        size++;
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "printState"); printState();
    }

    public PIndexedElem createPIndexedElem() {
        return new GenClassElement(this);
    }

    public boolean paDeltaSupported() {
        return true;
    }

    public int paGetNbElem() {
        return pIndexedElems.size();
    }

    public Iterator paIterator() {
        return pIndexedElems.iterator();
    }

    public void paSetNbElem(int nbelem) {
        TraceEjb.genclass.log(BasicLevel.DEBUG, "nbElem: " + nbelem);
        if (nbelem == -1) {
            pIndexedElems.clear();
        } else {
            pIndexedElems = new ArrayList(nbelem);
        }
        deletedLength = new int[0];
        size = 0;
    }


    // METHODS USABLE FOR THE SUB CLASS //
    //----------------------------------//

    protected int gcGetRealIndex(int idx) {
        int a = idx;
        int i = 0;
        while (i < deletedLength.length && (a -= deletedLength[i]) >= 0) {
            i++;
        }
        return idx + i;
    }

    protected void gcAdd(PObject element, boolean callListener) {
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "printState"); printState();
        int pos = 0;
        GenClassElement gce = null;
        int i = 0;
        while (i < deletedLength.length) {
            pos += deletedLength[i];
            gce = (GenClassElement) pIndexedElems.get(pos);
            if (gce.value == element) {
                break;
            }
            pos++;
            i++;
        }
        if (i < deletedLength.length) {
            if (gce.hasBeenCreated) {
                throw new EJBException("Internal error state: A deleted element has not been created");
            }
            TraceEjb.genclass.log(BasicLevel.DEBUG,
                                  "The element added was previously removed. i: " + i
                                  + "gce.pname: " + gce.pname);
            // The element was previously removed and added now.
            // - the status must be change to unmodified
            gce.status = PIndexedElem.ELEM_UNMODIFIED;
            if (deletedLength.length == 1) {
                deletedLength = new int[0];
            } else {
                int[] old = deletedLength;
                deletedLength = new int[deletedLength.length - 1];
                System.arraycopy(old, 0, deletedLength, 0, i);
                if (i < deletedLength.length) {
                    System.arraycopy(old, i + 1,
                                     deletedLength, i,
                                     deletedLength.length - i - 1);
                    deletedLength[i] += old[i] + 1;
                }
            }
        } else {
            if (TraceEjb.genclass.isLoggable(BasicLevel.DEBUG)) {
                try {
                    TraceEjb.genclass.log(BasicLevel.DEBUG, "Add the element '"
                            + element.getPName().encodeString());
                } catch (PExceptionNaming pExceptionNaming) {
                }
            }
            gce = (GenClassElement) createPIndexedElem();
            gce.value = element;
            gce.status = PIndexedElem.ELEM_CREATED;
            gce.hasBeenCreated = true;
            // Check if the element is legal, before added it (fix bug #300521)
            listener.isLegalElement(gce);
            pIndexedElems.add(gce);
        }
        isModified = true;
        size++;
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "printState"); printState();
        if (callListener) {
            listener.gcAdd(gce);
        }
    }

    protected Object gcRemove(Object element, boolean callListener) throws PException {
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "printState"); printState();
        GenClassElement gce = null;
        boolean found = false;
        int b = 0; //The number of existing element since the last deleted element
        int i = 0; // Quantity of deleted elements before
        int a;
        for (a = 0; a < pIndexedElems.size() && !found; a++) {
            gce = (GenClassElement) pIndexedElems.get(a);
            if (gce.status == PIndexedElem.ELEM_DELETED) {
                i++;
                b = 0;
                continue; //Do not search the element among the deleted elements
            }
            b++;
            if (gce.pname != null && gce.value == null) {
                gce.value = gcDeref(gce.pname);
            }
            found = (element == null && gce.value == null)
                || (element != null && element.equals(gce.value));
        }
        if (!found) {
            TraceEjb.genclass.log(BasicLevel.DEBUG, "Nothing to remove");
            return null;
        }

        // call listener before removing field
        if (callListener) {
            listener.gcRemove(gce, false);
        }
        if (gce.hasBeenCreated) {
            // Remove the element permanantly
            TraceEjb.genclass.log(BasicLevel.DEBUG, "Remove permanantly the element");
            pIndexedElems.remove(a - 1);
            if (i < deletedLength.length) {
                //decrease the number of existing element until the next deletec
                // element.
                deletedLength[i]--;
            }
        } else {
            //Mark the element as removed
            gce.status = PIndexedElem.ELEM_DELETED;

            // add the entry in the deletedLength array
            TraceEjb.genclass.log(BasicLevel.DEBUG,
                                  "Add the entry in the deletedLength array: i:" + i + " / b:" + b + ")");
            int[] old = deletedLength;
            deletedLength = new int[old.length + 1];
            System.arraycopy(old, 0, deletedLength, 0, i);
            deletedLength[i] = b - 1;
            if (i < old.length) {
                deletedLength[i + 1] = old[i] - b;
                System.arraycopy(old, i + 1, deletedLength, i + 2, old.length - i - 1);
            }
        }
        isModified = true;
        size--;
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "printState"); printState();
        return gce.value;
    }

    private static String toString(int[] t) {
        StringBuffer sb = new StringBuffer("[");
        for (int i = 0; i < t.length;) {
            sb.append(t[i]);
            i++;
            if (i < t.length) {
                sb.append(',');
            }
        }
        sb.append(']');
        return sb.toString();
    }

    public int gcGetSize() {
        return size;
    }

    protected boolean gcContains(PObject element, Object connection)
        throws PException {
        //Open a connection if the parameter is null
        Object conn = (connection == null
                       ? gcm.getPMapper().getConnection()
                       : connection);

        boolean result = false;
        for (Iterator it = gcIterator(conn); !result && it.hasNext();) {
            Object o = it.next();
            result =  (element == null && o == null)
                || (element != null && element.equals(o));
        }

        if (connection == null) {
            // close the localy opened connection
            gcm.getPMapper().closeConnection(conn);
        }
        if (TraceEjb.genclass.isLoggable(BasicLevel.DEBUG)) {
            try {
                TraceEjb.genclass.log(BasicLevel.DEBUG, "Looking for the element '"
                        + element.getPName().encodeString()
                        + ". return " + result);
            } catch (PExceptionNaming pExceptionNaming) {
            }
        }
        return result;
    }

    protected Iterator gcIterator() throws PException {
        return gcIterator(null);
    }

    protected Iterator gcIterator(Object connection) throws PException {
        return new ElementIterator(this, connection);
    }

    protected PObject gcGetElement(GenClassElement gce, Object connection) throws PException {
        if (gce.pname != null && gce.value == null) {
            // Dereference the PName
            if (gce.pname == null || gce.pname.isNull()) {
                return null;
            }
            PName current = gce.pname;

            // Allocate a connection if needed
            Object conn = (connection == null
                           ? gcm.getPMapper().getConnection()
                           : connection);

            // Resolve the pname
            Object res = current.resolve(conn);
            while (res != null && res instanceof PName && !res.equals(current)) {
                current = (PName) res;
                res = current.resolve(conn);
            }

            // close the connection opened localy
            if (connection == null) {
                gcm.getPMapper().closeConnection(conn);
            }

            // Fetch a Local Object on the factory of the referenced bean
            gce.value = gcDeref(current);
        }
        return gce.value;
    }

    public void gcClear(boolean delete) {
        TraceEjb.genclass.log(BasicLevel.DEBUG, "Clear the gc");
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "begin"); printState();

        // Call listener now because ejbRemove can still access fields.
        for (Iterator it = pIndexedElems.iterator(); it.hasNext();) {
            GenClassElement gce = (GenClassElement) it.next();
            if (gce.status != PIndexedElem.ELEM_DELETED) {
                if (gce.pname != null && gce.value == null) {
                    gce.value = gcDeref(gce.pname);
                }
                TraceEjb.genclass.log(BasicLevel.DEBUG, "listener.gcRemove");
                listener.gcRemove(gce, delete);
            }
        }

        // Mark all elements as DELETED or remove the created element.
        for (Iterator it = pIndexedElems.iterator(); it.hasNext();) {
            GenClassElement gce = (GenClassElement) it.next();
            if (gce.status != PIndexedElem.ELEM_DELETED) {
                gce.status = PIndexedElem.ELEM_DELETED;
                if (gce.hasBeenCreated) {
                    // Remove the element permanantly
                    TraceEjb.genclass.log(BasicLevel.DEBUG, "Clear permanantly an element");
                    it.remove();
                }
            }
        }
        // update the virtual size
        size = 0;
        isModified = true;

        // As all elements are deleted, the 'deletedLength' contains only 0
        // numbers. The size of this array is the same as the size of the
        // pIndexedElems list.
        deletedLength = new int[pIndexedElems.size()];
        Arrays.fill(deletedLength, 0);
        //TraceEjb.genclass.log(BasicLevel.DEBUG, "end"); printState();

    }

    protected PObject gcDeref(PName pn) {
        JEntityFactory f = (JEntityFactory)
            ((PBinder) pn.getPNameManager()).getBinderClassMapping();
        if (f.getLocalHome() != null) {
            return ((PObjectHome) f.getLocalHome()).getPObject(pn);
        } else {
            return ((PObjectHome) f.getHome()).getPObject(pn);
        }
    }

    protected PName gcObject2ref(PObject value) throws PException {
        if (value != null) {
            Object conn = gcm.getPMapper().getConnection();
            PNameManager pnm = (PNameManager) gcm.getPNameCoder();
            PName pn = pnm.export(conn, value.getPName(), null);
            gcm.getPMapper().closeConnection(conn);
            return pn;
        } else {
            return gcm.getPNameCoder().getNull();
        }
    }

    public void printState() {
        if (!TraceEjb.genclass.isLoggable(BasicLevel.DEBUG)) {
            return;
        }
        TraceEjb.genclass.log(BasicLevel.DEBUG, "deletedLength: " + toString(deletedLength));
        TraceEjb.genclass.log(BasicLevel.DEBUG, "pIndexedElems.size():" + pIndexedElems.size());
        TraceEjb.genclass.log(BasicLevel.DEBUG, "isModified: " + isModified);
        TraceEjb.genclass.log(BasicLevel.DEBUG, "size:" + size);
        int  i = 0;
        for (Iterator it = pIndexedElems.iterator(); it.hasNext();) {
            GenClassElement gce = (GenClassElement) it.next();
            TraceEjb.genclass.log(BasicLevel.DEBUG, "GCE:" + i
                                  + " / status:" + gce.status
                                  + " / hasBeenCreated:" + gce.hasBeenCreated
                                  );
            TraceEjb.genclass.log(BasicLevel.DEBUG, "- pname:" + gce.pname);
            TraceEjb.genclass.log(BasicLevel.DEBUG, "- value:" + gce.value);
            i++;
        }
    }

    protected class ElementIterator implements Iterator {

        private int cursor = 0;
        private int next = 0;
        private GenClassImpl gc;
        private Object conn;

        public ElementIterator(GenClassImpl gc, Object connection) {
            this.gc = gc;
            conn = connection;
            reset();
        }

        public void reset() {
            cursor = -1;
            next = nextExist(cursor);
        }

        private int nextExist(int pos) {
            int tmp = pos + 1;
            while (tmp < pIndexedElems.size()) {
                if (((GenClassElement) pIndexedElems.get(tmp)).status != PIndexedElem.ELEM_DELETED) {
                    //TraceEjb.genclass.log(BasicLevel.DEBUG, "nextExist("+pos+")="+tmp);
                    return tmp;
                }
                tmp++;
            }
            //TraceEjb.genclass.log(BasicLevel.DEBUG, "nextExist("+pos+")=-1");
            return -1;
        }

        // IMPLEMENTATION OF THE Iterator INTERFACE //
        //------------------------------------------//

        public boolean hasNext() {
            return next != -1;
        }

        public Object next() {
            if (next == -1) {
                throw new NoSuchElementException();
            }
            cursor = next;
            try {
                GenClassElement gce = (GenClassElement) pIndexedElems.get(cursor);
                gc.gcGetElement(gce, conn);
                //Caculate the next
                next = nextExist(cursor);
                return gce.value;
            } catch (PException e) {
                next = -1;
                TraceEjb.genclass.log(BasicLevel.ERROR, "Impossible to obtain value:", e);
                throw new NoSuchElementException("Impossible to obtain value:" + e);
            }
        }

        public void remove() {
            try {
                gcRemove(((GenClassElement) pIndexedElems.get(cursor)).value, true);
            } catch (PException e) {
                throw new UnsupportedOperationException(e.getMessage());
            }
        }
    }
}

---