public EntityManagerImpl() 
{
      
        // for Externalizable
}

 public EntityManagerImpl(EntityManagerFactoryImpl factory,
    Broker broker) 
{
        initialize(factory, broker);
}

Constructor; supply factory and delegate.

 public  void addLifecycleListener(Object listener,
    Class classes) 
{
        assertNotCloseInvoked();
        _broker.addLifecycleListener(listener, classes);
}

 public  void addTransactionListener(Object listener) 
{
        assertNotCloseInvoked();
        _broker.addTransactionListener(listener);
}

  void assertNotCloseInvoked() 
{
        if (!_broker.isClosed() && _broker.isCloseInvoked())
            throw new InvalidStateException(_loc.get("close-invoked"), null,
                null, true);
}

Throw appropriate exception if close has been invoked but the broker is still open. We test only for this because if the broker is already closed, it will throw its own more informative exception when we delegate the pending operation to it.

 public  void begin() 
{
        _broker.begin();
}

 public  void beginStore() 
{
        _broker.beginStore();
}

 public boolean cancelAll() 
{
        return _broker.cancelAll();
}

 public  void clear() 
{
        assertNotCloseInvoked();
        _broker.detachAll(this, false);
}

 public  void close() 
{
        assertNotCloseInvoked();
        _broker.close();
}

 public  void commit() 
{
        try {
            _broker.commit();
        } catch (RollbackException e) {
            throw e;
        } catch (IllegalStateException e) {
            throw e;
        } catch (Exception e) {
            // RollbackExceptions are special and aren't handled by the
            // normal exception translator, since the spec says they
            // should be thrown whenever the commit fails for any reason at
            // all, wheras the exception translator handles exceptions that
            // are caused for specific reasons
            throw new RollbackException(e);
        }
}

 public  void commitAndResume() 
{
        _broker.commitAndResume();
}

 public boolean contains(Object entity) 
{
        assertNotCloseInvoked();
        if (entity == null)
            return false;
        OpenJPAStateManager sm = _broker.getStateManager(entity);
        if (sm == null
            && !ImplHelper.isManagedType(getConfiguration(), entity.getClass()))
            throw new ArgumentException(_loc.get("not-entity",
                entity.getClass()), null, null, true);
        return sm != null && !sm.isDeleted();
}

 public boolean containsAll(Object entities) 
{
        for (Object entity : entities)
            if (!contains(entity))
                return false;
        return true;
}

 public boolean containsAll(Collection entities) 
{
        for (Object entity : entities)
            if (!contains(entity))
                return false;
        return true;
}

 public Extent createExtent(Class cls,
    boolean subclasses) 
{
        assertNotCloseInvoked();
        return new ExtentImpl< T >(this, _broker.newExtent(cls, subclasses));
}

 public T createInstance(Class cls) 
{
        assertNotCloseInvoked();
        return (T) _broker.newInstance(cls);
}

 public OpenJPAQuery createNamedQuery(String name) 
{
        assertNotCloseInvoked();
        _broker.assertOpen();
        try {
            QueryMetaData meta = _broker.getConfiguration().
                getMetaDataRepositoryInstance().getQueryMetaData(null, name,
                _broker.getClassLoader(), true);
            org.apache.openjpa.kernel.Query del =
                _broker.newQuery(meta.getLanguage(), null);
            meta.setInto(del);
            del.compile();
            OpenJPAQuery q = new QueryImpl(this, ret, del);
            String[] hints = meta.getHintKeys();
            Object[] values = meta.getHintValues();
            for (int i = 0; i <  hints.length; i++)
                q.setHint(hints[i], values[i]);
            return q;
        } catch (RuntimeException re) {
            throw PersistenceExceptions.toPersistenceException(re);
        }
}

 public OpenJPAQuery createNativeQuery(String query) 
{
        validateSQL(query);
        return createQuery(QueryLanguages.LANG_SQL, query);
}

 public OpenJPAQuery createNativeQuery(String query,
    Class cls) 
{
        return createNativeQuery(query).setResultClass(cls);
}

 public OpenJPAQuery createNativeQuery(String query,
    String mappingName) 
{
        assertNotCloseInvoked();
        validateSQL(query);
        org.apache.openjpa.kernel.Query kernelQuery = _broker.newQuery(
            QueryLanguages.LANG_SQL, query);
        kernelQuery.setResultMapping(null, mappingName);
        return new QueryImpl(this, ret, kernelQuery);
}

 public OpenJPAQuery createQuery(String query) 
{
        return createQuery(JPQLParser.LANG_JPQL, query);
}

 public OpenJPAQuery createQuery(Query query) 
{
        if (query == null)
            return createQuery((String) null);
        assertNotCloseInvoked();
        org.apache.openjpa.kernel.Query q = ((QueryImpl) query).getDelegate();
        return new QueryImpl(this, ret, _broker.newQuery(q.getLanguage(),
            q));
}

 public OpenJPAQuery createQuery(String language,
    String query) 
{
        assertNotCloseInvoked();
        return new QueryImpl(this, ret, _broker.newQuery(language, query));
}

 public T detach(T entity) 
{
        assertNotCloseInvoked();
        return (T) _broker.detach(entity, this);
}

 public Object[] detachAll(Object entities) 
{
        assertNotCloseInvoked();
        return _broker.detachAll(Arrays.asList(entities), this);
}

 public Collection detachAll(Collection entities) 
{
        assertNotCloseInvoked();
        return Arrays.asList(_broker.detachAll(entities, this));
}

 public  void dirty(Object o,
    String field) 
{
        assertNotCloseInvoked();
        OpenJPAStateManager sm = _broker.getStateManager(o);
        try {
            if (sm != null)
                sm.dirty(field);
        } catch (Exception e) {
            throw PersistenceExceptions.toPersistenceException(e);
        }
}

 public  void dirtyClass(Class cls) 
{
        assertNotCloseInvoked();
        _broker.dirtyType(cls);
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (!(other instanceof EntityManagerImpl))
            return false;
        return _broker.equals(((EntityManagerImpl) other)._broker);
}

 public  void evict(Object entity) 
{
        assertNotCloseInvoked();
        _broker.evict(entity, this);
}

 public  void evictAll() 
{
        assertNotCloseInvoked();
        _broker.evictAll(this);
}

 public  void evictAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.evictAll(entities, this);
}

 public  void evictAll(Object entities) 
{
        evictAll(Arrays.asList(entities));
}

 public  void evictAll(Class cls) 
{
        assertNotCloseInvoked();
        _broker.evictAll(_broker.newExtent(cls, true), this);
}

 public  void evictAll(Extent extent) 
{
        assertNotCloseInvoked();
        _broker.evictAll(((ExtentImpl) extent).getDelegate(), this);
}

 public T find(Class cls,
    Object oid) 
{
        assertNotCloseInvoked();
        oid = _broker.newObjectId(cls, oid);
        return (T) _broker.find(oid, true, this);
}

 public T[] findAll(Class cls,
    Object oids) 
{
        if (oids.length == 0)
            return (T[]) Array.newInstance(cls, 0);
        Collection< T > ret = findAll(cls, Arrays.asList(oids));
        return ret.toArray((T[]) Array.newInstance(cls, ret.size()));
}

 public Collection findAll(Class cls,
    Collection oids) 
{
        assertNotCloseInvoked();
        Object[] objs = _broker.findAll(oids, true, new FindCallbacks() {
            public Object processArgument(Object oid) {
                return _broker.newObjectId(cls, oid);
            }
            public Object processReturn(Object oid, OpenJPAStateManager sm) {
                return EntityManagerImpl.this.processReturn(oid, sm);
            }
        });
        return (Collection< T >) Arrays.asList(objs);
}

 public T findCached(Class cls,
    Object oid) 
{
        assertNotCloseInvoked();
        return (T) _broker.findCached(_broker.newObjectId(cls, oid), this);
}

 public  void flush() 
{
        assertNotCloseInvoked();
        _broker.assertOpen();
        _broker.assertActiveTransaction();
        _broker.flush();
}

 static FlushModeType fromFlushBeforeQueries(int flush) 
{
        switch (flush) {
            case QueryFlushModes.FLUSH_TRUE:
                return FlushModeType.AUTO;
            case QueryFlushModes.FLUSH_FALSE:
                return FlushModeType.COMMIT;
            default:
                return null;
        }
}

Translate our internal flush constant to a flush mode enum value.

 static LockModeType fromLockLevel(int level) 
{
        if (level <  LockLevels.LOCK_READ)
            return null;
        if (level <  LockLevels.LOCK_WRITE)
            return LockModeType.READ;
        return LockModeType.WRITE;
}

Translate our internal lock level to a javax.persistence enum value.

 public AutoClearType getAutoClear() 
{
        return AutoClearType.fromKernelConstant(_broker.getAutoClear());
}

 public EnumSet getAutoDetach() 
{
        return AutoDetachType.toEnumSet(_broker.getAutoDetach());
}

 public Broker getBroker() 
{
        return _broker.getDelegate();
}

Broker delegate.

 public ClassLoader getClassLoader() 
{
        return _broker.getClassLoader();
}

 public OpenJPAConfiguration getConfiguration() 
{
        return _broker.getConfiguration();
}

 public Object getConnection() 
{
        return _broker.getConnection();
}

 public String getConnectionPassword() 
{
        return _broker.getConnectionPassword();
}

 public ConnectionRetainMode getConnectionRetainMode() 
{
        return ConnectionRetainMode.fromKernelConstant(
            _broker.getConnectionRetainMode());
}

 public String getConnectionUserName() 
{
        return _broker.getConnectionUserName();
}

 public Object getDelegate() 
{
        _broker.assertOpen();
        assertNotCloseInvoked();
        return this;
}

 public DetachStateType getDetachState() 
{
        return DetachStateType.fromKernelConstant(_broker.getDetachState());
}

 public Collection getDirtyObjects() 
{
        return _broker.getDirtyObjects();
}

 public OpenJPAEntityManagerFactory getEntityManagerFactory() 
{
        return _emf;
}

 public boolean getEvictFromStoreCache() 
{
        return _broker.getEvictFromDataCache();
}

 public FetchPlan getFetchPlan() 
{
        assertNotCloseInvoked();
        _broker.lock();
        try {
            FetchConfiguration fc = _broker.getFetchConfiguration();
            FetchPlan fp = _plans.get(fc);
            if (fp == null) {
                fp = _emf.toFetchPlan(_broker, fc);
                _plans.put(fc, fp);
            }
            return fp;
        } finally {
            _broker.unlock();
        }
}

 public Generator getFieldGenerator(Class forClass,
    String fieldName) 
{
        assertNotCloseInvoked();
        try {
            ClassMetaData meta = _broker.getConfiguration().
                getMetaDataRepositoryInstance().getMetaData(forClass,
                _broker.getClassLoader(), true);
            FieldMetaData fmd = meta.getField(fieldName);
            if (fmd == null)
                throw new ArgumentException(_loc.get("no-named-field",
                    forClass, fieldName), null, null, false);
            Seq seq = _broker.getValueSequence(fmd);
            return (seq == null) ? null : new GeneratorImpl(seq, null, _broker,
                meta);
        } catch (Exception e) {
            throw PersistenceExceptions.toPersistenceException(e);
        }
}

 public FlushModeType getFlushMode() 
{
        assertNotCloseInvoked();
        _broker.assertOpen();
        return fromFlushBeforeQueries(_broker.getFetchConfiguration().
            getFlushBeforeQueries());
}

 public Generator getIdGenerator(Class forClass) 
{
        assertNotCloseInvoked();
        try {
            ClassMetaData meta = _broker.getConfiguration().
                getMetaDataRepositoryInstance().getMetaData(forClass,
                _broker.getClassLoader(), true);
            Seq seq = _broker.getIdentitySequence(meta);
            return (seq == null) ? null : new GeneratorImpl(seq, null, _broker,
                meta);
        } catch (Exception e) {
            throw PersistenceExceptions.toPersistenceException(e);
        }
}

 public boolean getIgnoreChanges() 
{
        return _broker.getIgnoreChanges();
}

 public int getLifecycleListenerCallbackMode() 
{
        return _broker.getLifecycleListenerCallbackMode();
}

 public EnumSet getLifecycleListenerCallbackModes() 
{
        return CallbackMode.toEnumSet(
            _broker.getLifecycleListenerCallbackMode());
}

 public LockModeType getLockMode(Object entity) 
{
        assertNotCloseInvoked();
        return fromLockLevel(_broker.getLockLevel(entity));
}

 public Collection getManagedObjects() 
{
        return _broker.getManagedObjects();
}

 public ManagedRuntime getManagedRuntime() 
{
        return _broker.getManagedRuntime();
}

 public boolean getMultithreaded() 
{
        return _broker.getMultithreaded();
}

 public Generator getNamedGenerator(String name) 
{
        assertNotCloseInvoked();
        try {
            SequenceMetaData meta = _broker.getConfiguration().
                getMetaDataRepositoryInstance().getSequenceMetaData(name,
                _broker.getClassLoader(), true);
            Seq seq = meta.getInstance(_broker.getClassLoader());
            return new GeneratorImpl(seq, name, _broker, null);
        } catch (RuntimeException re) {
            throw PersistenceExceptions.toPersistenceException(re);
        }
}

 public boolean getNontransactionalRead() 
{
        return _broker.getNontransactionalRead();
}

 public boolean getNontransactionalWrite() 
{
        return _broker.getNontransactionalWrite();
}

 public Object getObjectId(Object o) 
{
        assertNotCloseInvoked();
        return JPAFacadeHelper.fromOpenJPAObjectId(_broker.getObjectId(o));
}

 public Class getObjectIdClass(Class cls) 
{
        assertNotCloseInvoked();
        if (cls == null)
            return null;
        return JPAFacadeHelper.fromOpenJPAObjectIdClass
                (_broker.getObjectIdType(cls));
}

 public boolean getOptimistic() 
{
        return _broker.getOptimistic();
}

 public boolean getOrderDirtyObjects() 
{
        return _broker.getOrderDirtyObjects();
}

 public Collection getPendingTransactionalObjects() 
{
        return _broker.getPendingTransactionalObjects();
}

 public Collection getPersistedClasses() 
{
        return (Collection< Class >) _broker.getPersistedTypes();
}

 public boolean getPopulateStoreCache() 
{
        return _broker.getPopulateDataCache();
}

 public T getReference(Class cls,
    Object oid) 
{
        assertNotCloseInvoked();
        oid = _broker.newObjectId(cls, oid);
        return (T) _broker.find(oid, false, this);
}

 public Collection getRemovedClasses() 
{
        return (Collection< Class >) _broker.getDeletedTypes();
}

 public RestoreStateType getRestoreState() 
{
        return RestoreStateType.fromKernelConstant(_broker.getRestoreState());
}

 public boolean getRetainState() 
{
        return _broker.getRetainState();
}

 public Throwable getRollbackCause() 
{
        if (!isActive())
            throw new IllegalStateException(_loc.get("no-transaction")
                .getMessage());
        return _broker.getRollbackCause();
}

 public boolean getRollbackOnly() 
{
        if (!isActive())
            throw new IllegalStateException(_loc.get("no-transaction")
                .getMessage());
        return _broker.getRollbackOnly();
}

 public boolean getSyncWithManagedTransactions() 
{
        return _broker.getSyncWithManagedTransactions();
}

 public OpenJPAEntityTransaction getTransaction() 
{
        if (_broker.isManaged())
            throw new InvalidStateException(_loc.get("get-managed-trans"),
                null, null, false);
        return this;
}

 public int getTransactionListenerCallbackMode() 
{
        return _broker.getTransactionListenerCallbackMode();
}

 public EnumSet getTransactionListenerCallbackModes() 
{
        return CallbackMode.toEnumSet(
            _broker.getTransactionListenerCallbackMode());
}

 public Collection getTransactionalObjects() 
{
        return _broker.getTransactionalObjects();
}

 public Collection getUpdatedClasses() 
{
        return (Collection< Class >) _broker.getUpdatedTypes();
}

 public Object getUserObject(Object key) 
{
        return _broker.getUserObject(key);
}

 public Object getVersion(Object o) 
{
        assertNotCloseInvoked();
        return _broker.getVersion(o);
}

 public int hashCode() 
{
        return _broker.hashCode();
}

 public boolean isActive() 
{
        return isOpen() && _broker.isActive();
}

 public boolean isDetached(Object entity) 
{
        assertNotCloseInvoked();
        return _broker.isDetached(entity);
}

 public boolean isDirty(Object o) 
{
        assertNotCloseInvoked();
        return _broker.isDirty(o);
}

 public boolean isLargeTransaction() 
{
        return isTrackChangesByType();
}

 public boolean isManaged() 
{
        return _broker.isManaged();
}

 public boolean isNewlyPersistent(Object o) 
{
        assertNotCloseInvoked();
        return _broker.isNew(o);
}

 public boolean isOpen() 
{
        return !_broker.isCloseInvoked();
}

 public boolean isPersistent(Object o) 
{
        assertNotCloseInvoked();
        return _broker.isPersistent(o);
}

 public boolean isRemoved(Object o) 
{
        assertNotCloseInvoked();
        return _broker.isDeleted(o);
}

 public boolean isStoreActive() 
{
        return _broker.isStoreActive();
}

 public boolean isTrackChangesByType() 
{
        return _broker.isTrackChangesByType();
}

 public boolean isTransactionManaged() 
{
        return _broker.isManaged();
}

 public boolean isTransactional(Object o) 
{
        assertNotCloseInvoked();
        return _broker.isTransactional(o);
}

 public  void joinTransaction() 
{
        assertNotCloseInvoked();
        if (!_broker.syncWithManagedTransaction())
            throw new TransactionRequiredException(_loc.get
                ("no-managed-trans"), null, null, false);
}

 public  void lock(Object entity) 
{
        assertNotCloseInvoked();
        _broker.lock(entity, this);
}

 public  void lock(Object entity,
    LockModeType mode) 
{
        assertNotCloseInvoked();
        _broker.lock(entity, toLockLevel(mode), -1, this);
}

 public  void lock(Object entity,
    LockModeType mode,
    int timeout) 
{
        assertNotCloseInvoked();
        _broker.lock(entity, toLockLevel(mode), timeout, this);
}

 public  void lockAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.lockAll(entities, this);
}

 public  void lockAll(Object entities) 
{
        lockAll(Arrays.asList(entities));
}

 public  void lockAll(Collection entities,
    LockModeType mode,
    int timeout) 
{
        assertNotCloseInvoked();
        _broker.lockAll(entities, toLockLevel(mode), timeout, this);
}

 public  void lockAll(Object[] entities,
    LockModeType mode,
    int timeout) 
{
        lockAll(Arrays.asList(entities), mode, timeout);
}

 public T merge(T entity) 
{
        assertNotCloseInvoked();
        return (T) _broker.attach(entity, true, this);
}

 public Object[] mergeAll(Object entities) 
{
        if (entities.length == 0)
            return EMPTY_OBJECTS;
        return mergeAll(Arrays.asList(entities)).toArray();
}

 public Collection mergeAll(Collection entities) 
{
        assertNotCloseInvoked();
        return Arrays.asList(_broker.attachAll(entities, true, this));
}

 public  void nontransactional(Object entity) 
{
        assertNotCloseInvoked();
        _broker.nontransactional(entity, this);
}

 public  void nontransactionalAll(Collection objs) 
{
        assertNotCloseInvoked();
        _broker.nontransactionalAll(objs, this);
}

 public  void nontransactionalAll(Object[] objs) 
{
        assertNotCloseInvoked();
        _broker.nontransactionalAll(Arrays.asList(objs), this);
}

 public  void persist(Object entity) 
{
        assertNotCloseInvoked();
        _broker.persist(entity, this);
}

 public  void persistAll(Object entities) 
{
        persistAll(Arrays.asList(entities));
}

 public  void persistAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.persistAll(entities, this);
}

 public  void popFetchPlan() 
{
        assertNotCloseInvoked();
        _broker.lock();
        try {
            _broker.popFetchConfiguration();
        } finally {
            _broker.unlock();
        }
}

 public  void preFlush() 
{
        assertNotCloseInvoked();
        _broker.preFlush();
}

 public Object processArgument(Object arg) 
{
        return arg;
}

 public int processArgument(int op,
    Object obj,
    OpenJPAStateManager sm) 
{
        switch (op) {
            case OP_DELETE:
                // cascade through non-persistent non-detached instances
                if (sm == null && !_broker.isDetached(obj))
                    return ACT_CASCADE;
                if (sm != null && !sm.isDetached() && !sm.isPersistent())
                    return ACT_CASCADE;
                // ignore deleted instances
                if (sm != null && sm.isDeleted())
                    return ACT_NONE;
                break;
            case OP_ATTACH:
                // die on removed
                if (sm != null && sm.isDeleted())
                    throw new UserException(_loc.get("removed",
                        Exceptions.toString(obj))).setFailedObject(obj);
                // cascade through managed instances
                if (sm != null && !sm.isDetached())
                    return ACT_CASCADE;
                break;
            case OP_REFRESH:
                // die on unmanaged instances
                if (sm == null)
                    throw new UserException(_loc.get("not-managed",
                        Exceptions.toString(obj))).setFailedObject(obj);
                break;
        }
        return ACT_RUN | ACT_CASCADE;
}

 public Object processReturn(Object oid,
    OpenJPAStateManager sm) 
{
        return (sm == null || sm.isDeleted()) ? null : sm.getManagedInstance();
}

 public FetchPlan pushFetchPlan() 
{
        assertNotCloseInvoked();
        _broker.lock();
        try {
            _broker.pushFetchConfiguration();
            return getFetchPlan();
        } finally {
            _broker.unlock();
        }
}

 public Object putUserObject(Object key,
    Object val) 
{
        assertNotCloseInvoked();
        return _broker.putUserObject(key, val);
}

 public  void readExternal(ObjectInput in) throws ClassNotFoundException, IOException 
{
        try {
            ret = PersistenceExceptions.getRollbackTranslator(this);
            // this assumes that serialized Brokers are from something
            // that extends AbstractBrokerFactory.
            Object factoryKey = in.readObject();
            AbstractBrokerFactory factory =
                AbstractBrokerFactory.getPooledFactoryForKey(factoryKey);
            byte[] brokerBytes = (byte[]) in.readObject();
            ObjectInputStream innerIn = new BrokerBytesInputStream(brokerBytes,
                factory.getConfiguration());
            Broker broker = (Broker) innerIn.readObject();
            EntityManagerFactoryImpl emf = (EntityManagerFactoryImpl)
                JPAFacadeHelper.toEntityManagerFactory(
                    broker.getBrokerFactory());
            broker.putUserObject(JPAFacadeHelper.EM_KEY, this);
            initialize(emf, broker);
        } catch (RuntimeException re) {
            try {
                re = ret.translate(re);
            } catch (Exception e) {
                // ignore
            }
            throw re;
        }
}

 public  void refresh(Object entity) 
{
        assertNotCloseInvoked();
        _broker.assertWriteOperation();
        _broker.refresh(entity, this);
}

 public  void refreshAll() 
{
        assertNotCloseInvoked();
        _broker.assertWriteOperation();
        _broker.refreshAll(_broker.getTransactionalObjects(), this);
}

 public  void refreshAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.assertWriteOperation();
        _broker.refreshAll(entities, this);
}

 public  void refreshAll(Object entities) 
{
        refreshAll(Arrays.asList(entities));
}

 public  void release(Object entity) 
{
        assertNotCloseInvoked();
        _broker.release(entity, this);
}

 public  void releaseAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.releaseAll(entities, this);
}

 public  void releaseAll(Object entities) 
{
        releaseAll(Arrays.asList(entities));
}

 public  void releaseSavepoint() 
{
        assertNotCloseInvoked();
        _broker.releaseSavepoint();
}

 public  void releaseSavepoint(String name) 
{
        assertNotCloseInvoked();
        _broker.releaseSavepoint(name);
}

 public  void remove(Object entity) 
{
        assertNotCloseInvoked();
        _broker.delete(entity, this);
}

 public  void removeAll(Object entities) 
{
        removeAll(Arrays.asList(entities));
}

 public  void removeAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.deleteAll(entities, this);
}

 public  void removeLifecycleListener(Object listener) 
{
        assertNotCloseInvoked();
        _broker.removeLifecycleListener(listener);
}

 public  void removeTransactionListener(Object listener) 
{
        assertNotCloseInvoked();
        _broker.removeTransactionListener(listener);
}

 public  void retrieve(Object entity) 
{
        assertNotCloseInvoked();
        _broker.retrieve(entity, true, this);
}

 public  void retrieveAll(Collection entities) 
{
        assertNotCloseInvoked();
        _broker.retrieveAll(entities, true, this);
}

 public  void retrieveAll(Object entities) 
{
        retrieveAll(Arrays.asList(entities));
}

 public  void rollback() 
{
        _broker.rollback();
}

 public  void rollbackAndResume() 
{
        _broker.rollbackAndResume();
}

 public  void rollbackToSavepoint() 
{
        assertNotCloseInvoked();
        _broker.rollbackToSavepoint();
}

 public  void rollbackToSavepoint(String name) 
{
        assertNotCloseInvoked();
        _broker.rollbackToSavepoint(name);
}

 public  void setAutoClear(AutoClearType val) 
{
        assertNotCloseInvoked();
        _broker.setAutoClear(val.toKernelConstant());
}

 public  void setAutoClear(int autoClear) 
{
        assertNotCloseInvoked();
        _broker.setAutoClear(autoClear);
}

 public  void setAutoDetach(AutoDetachType flag) 
{
        assertNotCloseInvoked();
        _broker.setAutoDetach(AutoDetachType.fromEnumSet(EnumSet.of(flag)));
}

 public  void setAutoDetach(EnumSet flags) 
{
        assertNotCloseInvoked();
        _broker.setAutoDetach(AutoDetachType.fromEnumSet(flags));
}

 public  void setAutoDetach(int autoDetachFlags) 
{
        assertNotCloseInvoked();
        _broker.setAutoDetach(autoDetachFlags);
}

 public  void setAutoDetach(AutoDetachType value,
    boolean on) 
{
        assertNotCloseInvoked();
        _broker.setAutoDetach(AutoDetachType.fromEnumSet(EnumSet.of(value)),on);
}

 public  void setAutoDetach(int flag,
    boolean on) 
{
        assertNotCloseInvoked();
        _broker.setAutoDetach(flag, on);
}

 public  void setDetachState(DetachStateType type) 
{
        assertNotCloseInvoked();
        _broker.setDetachState(type.toKernelConstant());
}

 public  void setDetachState(int detach) 
{
        assertNotCloseInvoked();
        _broker.setDetachState(detach);
}

 public  void setEvictFromStoreCache(boolean evict) 
{
        assertNotCloseInvoked();
        _broker.setEvictFromDataCache(evict);
}

 public  void setFlushMode(FlushModeType flushMode) 
{
        assertNotCloseInvoked();
        _broker.assertOpen();
        _broker.getFetchConfiguration().setFlushBeforeQueries
            (toFlushBeforeQueries(flushMode));
}

 public  void setIgnoreChanges(boolean val) 
{
        assertNotCloseInvoked();
        _broker.setIgnoreChanges(val);
}

 public  void setLargeTransaction(boolean value) 
{
        setTrackChangesByType(value);
}

 public  void setLifecycleListenerCallbackMode(CallbackMode mode) 
{
        assertNotCloseInvoked();
        _broker.setLifecycleListenerCallbackMode(
            CallbackMode.fromEnumSet(EnumSet.of(mode)));
}

 public  void setLifecycleListenerCallbackMode(EnumSet modes) 
{
        assertNotCloseInvoked();
        _broker.setLifecycleListenerCallbackMode(
            CallbackMode.fromEnumSet(modes));
}

 public  void setLifecycleListenerCallbackMode(int callbackMode) 
{
        assertNotCloseInvoked();
        _broker.setLifecycleListenerCallbackMode(callbackMode);
}

 public  void setMultithreaded(boolean multithreaded) 
{
        assertNotCloseInvoked();
        _broker.setMultithreaded(multithreaded);
}

 public  void setNontransactionalRead(boolean val) 
{
        assertNotCloseInvoked();
        _broker.setNontransactionalRead(val);
}

 public  void setNontransactionalWrite(boolean val) 
{
        assertNotCloseInvoked();
        _broker.setNontransactionalWrite(val);
}

 public  void setOptimistic(boolean val) 
{
        assertNotCloseInvoked();
        _broker.setOptimistic(val);
}

 public  void setOrderDirtyObjects(boolean order) 
{
        assertNotCloseInvoked();
        _broker.setOrderDirtyObjects(order);
}

 public  void setPopulateStoreCache(boolean cache) 
{
        assertNotCloseInvoked();
        _broker.setPopulateDataCache(cache);
}

 public  void setRestoreState(RestoreStateType val) 
{
        assertNotCloseInvoked();
        _broker.setRestoreState(val.toKernelConstant());
}

 public  void setRestoreState(int restore) 
{
        assertNotCloseInvoked();
        _broker.setRestoreState(restore);
}

 public  void setRetainState(boolean val) 
{
        assertNotCloseInvoked();
        _broker.setRetainState(val);
}

 public  void setRollbackOnly() 
{
        _broker.setRollbackOnly();
}

 public  void setRollbackOnly(Throwable cause) 
{
        _broker.setRollbackOnly(cause);
}

 public  void setSavepoint(String name) 
{
        assertNotCloseInvoked();
        _broker.setSavepoint(name);
}

 public  void setSyncWithManagedTransactions(boolean sync) 
{
        assertNotCloseInvoked();
        _broker.setSyncWithManagedTransactions(sync);
}

 public  void setTrackChangesByType(boolean trackByType) 
{
        assertNotCloseInvoked();
        _broker.setTrackChangesByType(trackByType);
}

 public  void setTransactionListenerCallbackMode(CallbackMode mode) 
{
        assertNotCloseInvoked();
        _broker.setTransactionListenerCallbackMode(
            CallbackMode.fromEnumSet(EnumSet.of(mode)));
}

 public  void setTransactionListenerCallbackMode(EnumSet modes) 
{
        assertNotCloseInvoked();
        _broker.setTransactionListenerCallbackMode(
            CallbackMode.fromEnumSet(modes));
}

 public  void setTransactionListenerCallbackMode(int callbackMode) 
{
        throw new UnsupportedOperationException();
}

 static int toFlushBeforeQueries(FlushModeType flushMode) 
{
        // choose default for null
        if (flushMode == null)
            return QueryFlushModes.FLUSH_WITH_CONNECTION;
        if (flushMode == FlushModeType.AUTO)
            return QueryFlushModes.FLUSH_TRUE;
        if (flushMode == FlushModeType.COMMIT)
            return QueryFlushModes.FLUSH_FALSE;
        throw new ArgumentException(flushMode.toString(), null, null, false);
}

Translate a flush mode enum value to our internal flush constant.

 static int toLockLevel(LockModeType mode) 
{
        if (mode == null)
            return LockLevels.LOCK_NONE;
        if (mode == LockModeType.READ)
            return LockLevels.LOCK_READ;
        if (mode == LockModeType.WRITE)
            return LockLevels.LOCK_WRITE;
        throw new ArgumentException(mode.toString(), null, null, true);
}

Translate the javax.persistence enum value to our internal lock level.

 public  void transactional(Object entity,
    boolean updateVersion) 
{
        assertNotCloseInvoked();
        _broker.transactional(entity, updateVersion, this);
}

 public  void transactionalAll(Collection objs,
    boolean updateVersion) 
{
        assertNotCloseInvoked();
        _broker.transactionalAll(objs, updateVersion, this);
}

 public  void transactionalAll(Object[] objs,
    boolean updateVersion) 
{
        assertNotCloseInvoked();
        _broker.transactionalAll(Arrays.asList(objs), updateVersion, this);
}

 public  void validateChanges() 
{
        assertNotCloseInvoked();
        _broker.validateChanges();
}

 public  void writeExternal(ObjectOutput out) throws IOException 
{
        try {
            // this requires that only AbstractBrokerFactory-sourced
            // brokers can be serialized
            Object factoryKey = ((AbstractBrokerFactory) _broker
                .getBrokerFactory()).getPoolKey();
            out.writeObject(factoryKey);
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream innerOut = new ObjectOutputStream(baos);
            innerOut.writeObject(_broker.getDelegate());
            innerOut.flush();
            out.writeObject(baos.toByteArray());
        } catch (RuntimeException re) {
            try {
                re = ret.translate(re);
            } catch (Exception e) {
                // ignore
            }
            throw re;
        }
}