JEntitySwitchRO.java

package org.objectweb.jonas_ejb.container;

import javax.ejb.EJBException;
import javax.transaction.SystemException;
import javax.transaction.Transaction;

import org.objectweb.jonas_ejb.deployment.api.EntityDesc;

import org.objectweb.util.monolog.api.BasicLevel;

public class JEntitySwitchRO extends JEntitySwitch {

    protected JEntityContext itContext = null;

    public JEntitySwitchRO() {
        lockpolicy = EntityDesc.LOCK_READ_ONLY;
        txUpdates = true;       // never write anyway.
    }

    protected void initpolicy(JEntityFactory bf) {
        lazyregister = true;    // never write anyway.
    }

    protected JEntityContext getContext4Tx(Transaction tx) {
        return itContext;
    }

    protected void setContext4Tx(Transaction tx, JEntityContext ctx) {
        itContext = ctx;
    }

    protected void removeContext4Tx(Transaction tx) {
        itContext = null;
    }

    public void waitmyturn(Transaction tx) {
        // No synchro for this policy.
    }

    public synchronized JEntityContext mapICtx(Transaction tx, JEntityContext bctx, boolean forced, boolean holdit, boolean notused) {

        waitmyturn(tx);

        // Choose the context to use.
        boolean newtrans = false;
        JEntityContext jec = itContext;
        if (forced) {
            TraceEjb.context.log(BasicLevel.ERROR, ident + "create cannot be called on read only bean");
            throw new EJBException("Read Only bean");
        } else {
            if (jec != null) {
                // Reuse the Context for this transaction.
                // If a context was supplied, release it first.
                if (bctx != null) {
                    if (TraceEjb.isDebugContext())
                            TraceEjb.context.log(BasicLevel.DEBUG, ident + "a context was supplied!");
                    bf.releaseJContext(bctx);
                }
                newtrans = true;
                jec.reuseEntityContext(newtrans);
            } else {
                if (bctx != null) {
                    jec = bctx;
                } else {
                    // no Context available : get one from the pool.
                    jec = (JEntityContext) bf.getJContext(this);
                }
                jec.initEntityContext(this);
                jec.activate(true);
                itContext = jec; // after activate
                newtrans = true;
            }
        }

        if (tx == null) {
            if (holdit) {
                countIH++;
                if (TraceEjb.isDebugSynchro())
                        TraceEjb.synchro.log(BasicLevel.DEBUG, ident + "mapICtx IH count=" + countIH);
                if (shared && countIH == 1) {
                    // reload state that could have been modified by
                    // transactions.
                    jec.activate(false);
                }
            }
        } else {
            if (holdit) {
                countIT++;
            }
        }

        return jec;
    }

    public boolean passivateIH(boolean passivation) {
        JEntityContext jec = getContext4Tx(null);
        // If already passivated, look if we can destroy the objects
        if (jec == null) {
            if (inactivityTimeout > 0 &&
                System.currentTimeMillis() - timestamp > inactivityTimeout) {
                TraceEjb.context.log(BasicLevel.DEBUG, "discard object on timeout");
                discardContext(null, true, false);
            }
            return true;
        }
        // passivate this instance if required.
        if (passivation) {
            if (TraceEjb.isDebugContext()) TraceEjb.context.log(BasicLevel.DEBUG, "TODO: passivate: " + jec);
        }
        return true;
    }

    public void endIH() {
        return; // NEVER
    }

    public synchronized void notifyWriting(Transaction tx, JEntityContext bctx) {
        TraceEjb.context.log(BasicLevel.ERROR, ident + "read only bean: cannot write");
        throw new EJBException("Read Only bean");
    }

    public int getState() {
        if (itContext != null) {
            if (itContext.isMarkedRemoved()) {
                return 4;
            } else {
                if (writingtx != null) {
                    return 0;
                } else {
                    return 1;
                }
            }
        }
        return 3;
    }

}

---