protected StateManagerImpl(Object id,
    ClassMetaData meta,
    BrokerImpl broker) 
{
                  
        _id = id;
        _meta = meta;
        _broker = broker;
        _single = new SingleFieldManager(this, broker);
        if (_meta.getIdentityType() == ClassMetaData.ID_UNKNOWN)
            throw new UserException(_loc.get("meta-unknownid", _meta));
}

Constructor; supply id, type metadata, and owning persistence manager.

 public  void accessingField(int field) 
{
        // possibly change state
        try {
            beforeRead(field);
            beforeAccessField(field);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

  void afterFlush(int reason) 
{
        // nothing happens when we flush non-persistent states
        if (!isPersistent())
            return;
        if (reason != BrokerImpl.FLUSH_ROLLBACK
            && reason != BrokerImpl.FLUSH_LOGICAL) {
            // analyze previous state for later
            boolean wasNew = isNew();
            boolean wasFlushed = isFlushed();
            boolean wasDeleted = isDeleted();
            // all dirty fields were flushed
            _flush.or(_dirty);
            // important to set flushed bit after calling _state.flush so
            // that the state can tell whether this is the first flush
            setPCState(_state.flush(this));
            _flags |= FLAG_FLUSHED;
            _flags &= ~FLAG_FLUSHED_DIRTY;
            _flags &= ~FLAG_VERSION_CHECK;
            _flags &= ~FLAG_VERSION_UPDATE;
            // if this was an inc flush during which we had our identity
            // assigned, tell the broker to cache us under our final oid
            if (reason == BrokerImpl.FLUSH_INC)
                assertObjectIdAssigned(true);
            // if this object was stored with preFlush, do post-store callback
            if ((_flags & FLAG_PRE_FLUSHED)  > 0)
                fireLifecycleEvent(LifecycleEvent.AFTER_STORE);
            // do post-update as needed
            if (wasNew && !wasFlushed)
                fireLifecycleEvent(LifecycleEvent.AFTER_PERSIST_PERFORMED);
            else if (wasDeleted)
                fireLifecycleEvent(LifecycleEvent.AFTER_DELETE_PERFORMED);
            else 
                // updates and new-flushed with changes
                fireLifecycleEvent(LifecycleEvent.AFTER_UPDATE_PERFORMED);
        } else if (reason == BrokerImpl.FLUSH_ROLLBACK) {
            // revert to last loaded version and original oid
            assignVersionField(_loadVersion);
            if (isNew() && (_flags & FLAG_OID_ASSIGNED) == 0)
                _oid = null;
        }
        _flags &= ~FLAG_PRE_FLUSHED;
}

Delegates to the current state.

  void afterRefresh() 
{
        lock();
        try {
            // transition to clean or nontransactional depending on trans status
            if (!_broker.isActive())
                setPCState(_state.afterNontransactionalRefresh());
            else if (_broker.getOptimistic())
                setPCState(_state.afterOptimisticRefresh());
            else
                setPCState(_state.afterRefresh());
        } finally {
            unlock();
        }
}

Perform state transitions after refresh. This method is only called if #beforeRefresh returns true.

  void assertNotManagedObjectId(Object val) 
{
        if (val != null
            && (ImplHelper.toPersistenceCapable(val,
                 getContext().getConfiguration())).pcGetGenericContext()!= null)
            throw translate(new InvalidStateException(_loc.get
                ("managed-oid", Exceptions.toString(val),
                    Exceptions.toString(getManagedInstance()))).
                setFailedObject(getManagedInstance()));
}

Disallows setting an object id field to a managed instance.

 public boolean assignObjectId(boolean flush) 
{
        lock();
        try {
            return assignObjectId(flush, false);
        } finally {
            unlock();
        }
}

 protected  void beforeAccessField(int field) 
{
        lock();
        try {
            boolean active = _broker.isActive();
            int lockLevel = calculateLockLevel(active, false, null);
            if (!_loaded.get(field))
                loadField(field, lockLevel, false, true);
            else
                assignField(field, false);
            obtainLocks(active, false, lockLevel, null, null);
        } catch (RuntimeException re) {
            throw translate(re);
        } finally {
            unlock();
        }
}

Load the given field before access.

  void beforeFlush(int reason,
    OpCallbacks call) 
{
        _state.beforeFlush(this, reason == BrokerImpl.FLUSH_LOGICAL, call);
}

Delegates to the current state.

  void beforeRead(int field) 
{
        // allow unmediated reads of primary key fields
        if (field != -1 && _meta.getField(field).isPrimaryKey())
            return;
        if (_broker.isActive() && !_broker.isTransactionEnding()) {
            if (_broker.getOptimistic())
                setPCState(_state.beforeOptimisticRead(this, field));
            else
                setPCState(_state.beforeRead(this, field));
        } else if (_broker.getNontransactionalRead())
            setPCState(_state.beforeNontransactionalRead(this, field));
        else
            throw new InvalidStateException(_loc.get("non-trans-read")).
                setFailedObject(getManagedInstance());
}

Notification that the object is about to be accessed.

 public boolean beforeRefresh(boolean refreshAll) 
{
        // note: all logic placed here rather than in the states for
        // optimization; this method public b/c used by remote package
        // nothing to do for non persistent or new unflushed instances
        if (!isPersistent() || (isNew() && !isFlushed()))
            return false;
        lock();
        try {
            // if dirty need to clear fields
            if (isDirty()) {
                clearFields();
                return true;
            }
            // if some fields have been loaded but the instance is out of
            // date or this is part of a refreshAll() and we don't want to
            // take the extra hit to see if the instance is out of date, clear
            if (_loaded.length()  > 0 && (refreshAll || isEmbedded()
                || !syncVersion(null))) {
                Object version = _version;
                clearFields();
                // if syncVersion just replaced the version, reset it
                if (!refreshAll && !isEmbedded())
                    setVersion(version);
                return true;
            }
            return false;
        } finally {
            unlock();
        }
}

  void cascadeDelete(OpCallbacks call) 
{
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (fmds[i].getCascadeDelete() != ValueMetaData.CASCADE_NONE
                || fmds[i].getKey().getCascadeDelete()
                != ValueMetaData.CASCADE_NONE
                || fmds[i].getElement().getCascadeDelete()
                != ValueMetaData.CASCADE_NONE) {
                _single.storeObjectField(i, fetchField(i, false));
                _single.delete(call);
                _single.clear();
            }
        }
}

Cascade deletes and dereference dependent fields.

  void cascadePersist(OpCallbacks call) 
{
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (!_loaded.get(i))
                continue;
            if (fmds[i].getCascadePersist() == ValueMetaData.CASCADE_IMMEDIATE
                || fmds[i].getKey().getCascadePersist()
                == ValueMetaData.CASCADE_IMMEDIATE
                || fmds[i].getElement().getCascadePersist()
                == ValueMetaData.CASCADE_IMMEDIATE) {
                _single.storeObjectField(i, fetchField(i, false));
                _single.persist(call);
                _single.clear();
            }
        }
}

Called after an instance is persisted by a user through the broker. Cascades the persist operation to fields marked ValueMetaData#CASCADE_IMMEDIATE .

  void clearFields() 
{
        if (!isIntercepting())
            return;
        fireLifecycleEvent(LifecycleEvent.BEFORE_CLEAR);
        // unproxy all fields
        unproxyFields();
        lock();
        try {
            // clear non-pk fields
            FieldMetaData[] fmds = _meta.getFields();
            for (int i = 0; i <  fmds.length; i++) {
                if (!fmds[i].isPrimaryKey() && fmds[i].getManagement()
                    == FieldMetaData.MANAGE_PERSISTENT)
                    replaceField(_pc, ClearFieldManager.getInstance(), i);
            }
            // forget version info and impl data so we re-read next time
            setLoaded(false);
            _version = null;
            _loadVersion = null;
            if (_fieldImpl != null)
                Arrays.fill(_fieldImpl, null);
        } finally {
            unlock();
        }
        fireLifecycleEvent(LifecycleEvent.AFTER_CLEAR);
}

Executes pre-clear callbacks, clears all managed fields, and calls the #setLoaded method with a value of false. Primary key fields are not cleared.

  void clearSavedFields() 
{
        if (isIntercepting()) {
            _flags &= ~FLAG_SAVE;
            _saved = null;
        }
}

Notification that the state will not need to be rolled back to that of the last call to #saveFields .

  void commit() 
{
        // release locks before oid updated
        releaseLocks();
        // update version and oid information
        setVersion(_version);
        _flags &= ~FLAG_FLUSHED;
        _flags &= ~FLAG_FLUSHED_DIRTY;
        Object orig = _id;
        assertObjectIdAssigned(false);
        boolean wasNew = isNew() && !isDeleted() && !isProvisional();
        if (_broker.getRetainState())
            setPCState(_state.commitRetain(this));
        else
            setPCState(_state.commit(this));
        // ask the broker to re-cache us if we were new previously
        if (wasNew)
            _broker.setStateManager(orig, this, BrokerImpl.STATUS_COMMIT_NEW);
}

Delegates to the current state after checking the value of the RetainState flag.

  void delete() 
{
        setPCState(_state.delete(this));
}

Delegates to the current state.

 public  void dirty(String field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (fmd == null)
            throw translate(new UserException(_loc.get("no-field", field,
                ImplHelper.getManagedInstance(_pc).getClass()))
                .setFailedObject(getManagedInstance()));
        dirty(fmd.getIndex(), null, true);
}

 public  void dirty(int field) 
{
        dirty(field, null, true);
}

 public  void dirtyCheck() 
{
        if (!needsDirtyCheck())
            return;
        SaveFieldManager saved = getSaveFieldManager();
        if (saved == null)
            throw new InternalException(_loc.get("no-saved-fields",
                getMetaData().getDescribedType().getName()));
        FieldMetaData[] fmds = getMetaData().getFields();
        for (int i = 0; i <  fmds.length; i++) {
            // pk and version fields cannot be mutated; don't mark them
            // as such. ##### validate?
            if (!fmds[i].isPrimaryKey() && !fmds[i].isVersion()
                && _loaded.get(i)) {
                if (!saved.isFieldEqual(i, fetch(i))) {
                    dirty(i);
                }
            }
        }
}

Checks whether or not _pc is dirty. In the cases where field tracking is not happening (see below), this method will do a state comparison to find whether _pc is dirty, and will update this instance with this information. In the cases where field tracking is happening, this method is a no-op.

Fields are tracked for all classes that are run through the OpenJPA enhancer prior to or during deployment, and all classes (enhanced or unenhanced) in a Java 6 environment or newer.

In a Java 5 VM or older:
- instances of unenhanced classes that use property access and obey the property access limitations are tracked when the instances are loaded from the database by OpenJPA, and are not tracked when the instances are created by application code.
- instances of unenhanced classes that use field access are never tracked.

  void eraseFlush() 
{
        _flags &= ~FLAG_FLUSHED;
        _flags &= ~FLAG_FLUSHED_DIRTY;
        int fmds = _meta.getFields().length;
        for (int i = 0; i <  fmds; i++)
            _flush.clear(i);
}

Erase the fact that this instance has been flushed.

  void evict() 
{
        setPCState(_state.evict(this));
}

Delegates to the current state.

 public Object fetch(int field) 
{
        Object val = fetchField(field, false);
        return _meta.getField(field).getExternalValue(val, _broker);
}

 public boolean fetchBoolean(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchBooleanField(field);
        Object val = fetchField(field, false);
        return ((Boolean) fmd.getExternalValue(val, _broker)).booleanValue();
}

 public boolean fetchBooleanField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchBooleanField(field);
        } finally {
            unlock();
        }
}

 public byte fetchByte(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchByteField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).byteValue();
}

 public byte fetchByteField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchByteField(field);
        } finally {
            unlock();
        }
}

 public char fetchChar(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchCharField(field);
        Object val = fetchField(field, false);
        return ((Character) fmd.getExternalValue(val, _broker)).charValue();
}

 public char fetchCharField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchCharField(field);
        } finally {
            unlock();
        }
}

 public double fetchDouble(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchDoubleField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).doubleValue();
}

 public double fetchDoubleField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchDoubleField(field);
        } finally {
            unlock();
        }
}

 public Object fetchField(int field,
    boolean transitions) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (fmd == null)
            throw new UserException(_loc.get("no-field",
                String.valueOf(field), getManagedInstance().getClass())).
                setFailedObject(getManagedInstance());
        // do normal state transitions
        if (!fmd.isPrimaryKey() && transitions)
            accessingField(field);
        switch (fmd.getDeclaredTypeCode()) {
            case JavaTypes.STRING:
                return fetchStringField(field);
            case JavaTypes.OBJECT:
                return fetchObjectField(field);
            case JavaTypes.BOOLEAN:
                return (fetchBooleanField(field)) ? Boolean.TRUE
                    : Boolean.FALSE;
            case JavaTypes.BYTE:
                return new Byte(fetchByteField(field));
            case JavaTypes.CHAR:
                return new Character(fetchCharField(field));
            case JavaTypes.DOUBLE:
                return new Double(fetchDoubleField(field));
            case JavaTypes.FLOAT:
                return new Float(fetchFloatField(field));
            case JavaTypes.INT:
                return Numbers.valueOf(fetchIntField(field));
            case JavaTypes.LONG:
                return Numbers.valueOf(fetchLongField(field));
            case JavaTypes.SHORT:
                return new Short(fetchShortField(field));
            default:
                return fetchObjectField(field);
        }
}

 public float fetchFloat(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchFloatField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).floatValue();
}

 public float fetchFloatField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchFloatField(field);
        } finally {
            unlock();
        }
}

 public Object fetchInitialField(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (_broker.getRestoreState() == RestoreState.RESTORE_NONE
            && ((_flags & FLAG_INVERSES) == 0
            || fmd.getInverseMetaDatas().length == 0))
            throw new InvalidStateException(_loc.get("restore-unset"));
        switch (fmd.getDeclaredTypeCode()) {
            case JavaTypes.DATE:
            case JavaTypes.CALENDAR:
            case JavaTypes.ARRAY:
            case JavaTypes.COLLECTION:
            case JavaTypes.MAP:
            case JavaTypes.OBJECT:
                // if we're not saving mutable types, throw an exception
                if (_broker.getRestoreState() != RestoreState.RESTORE_ALL
                    && ((_flags & FLAG_INVERSES) == 0
                    || fmd.getInverseMetaDatas().length == 0))
                    throw new InvalidStateException(_loc.get
                        ("mutable-restore-unset"));
        }
        lock();
        try {
            if (_saved == null || !_loaded.get(field) || !_dirty.get(field))
                return fetchField(field, false);
            // if the field is dirty but we never loaded it, we can't restore it
            if (_saved.getUnloaded().get(field))
                throw new InvalidStateException(_loc.get("initial-unloaded",
                    fmd));
            provideField(_saved.getState(), _single, field);
            return fetchField(_single, fmd);
        } finally {
            unlock();
        }
}

 public int fetchInt(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchIntField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).intValue();
}

 public int fetchIntField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchIntField(field);
        } finally {
            unlock();
        }
}

 public long fetchLong(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchLongField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).longValue();
}

 public long fetchLongField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchLongField(field);
        } finally {
            unlock();
        }
}

 public Object fetchObject(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchObjectField(field);
        Object val = fetchField(field, false);
        return fmd.getExternalValue(val, _broker);
}

 public Object fetchObjectField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchObjectField(field);
        } finally {
            unlock();
        }
}

 public Object fetchObjectId() 
{
        try {
            assignObjectId(true);
            if (_oid == null || !_broker.getConfiguration().
                getCompatibilityInstance().getCopyObjectIds())
                return _oid;
            if (_meta.getIdentityType() == ClassMetaData.ID_DATASTORE)
                return _broker.getStoreManager().copyDataStoreId(_oid, _meta);
            return ApplicationIds.copy(_oid, _meta);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public short fetchShort(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchShortField(field);
        Object val = fetchField(field, false);
        return ((Number) fmd.getExternalValue(val, _broker)).shortValue();
}

 public short fetchShortField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchShortField(field);
        } finally {
            unlock();
        }
}

 public String fetchString(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return fetchStringField(field);
        Object val = fetchField(field, false);
        return (String) fmd.getExternalValue(val, _broker);
}

 public String fetchStringField(int field) 
{
        lock();
        try {
            if (!_loaded.get(field))
                loadField(field, LockLevels.LOCK_NONE, false, false);
            provideField(_pc, _single, field);
            return _single.fetchStringField(field);
        } finally {
            unlock();
        }
}

  void gatherCascadeRefresh(OpCallbacks call) 
{
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (!_loaded.get(i))
                continue;
            if (fmds[i].getCascadeRefresh() == ValueMetaData.CASCADE_IMMEDIATE
                || fmds[i].getKey().getCascadeRefresh()
                == ValueMetaData.CASCADE_IMMEDIATE
                || fmds[i].getElement().getCascadeRefresh()
                == ValueMetaData.CASCADE_IMMEDIATE) {
                _single.storeObjectField(i, fetchField(i, false));
                _single.gatherCascadeRefresh(call);
                _single.clear();
            }
        }
}

Gather relations reachable from values using ValueMetaData#CASCADE_IMMEDIATE .

 BrokerImpl getBroker() 
{
        return _broker;
}

Managing broker.

 public StoreContext getContext() 
{
        return _broker;
}

 public BitSet getDirty() 
{
        return _dirty;
}

 public BitSet getFlushed() 
{
        return _flush;
}

 public Object getGenericContext() 
{
        return _broker;
}

 public Object getId() 
{
        return _id;
}

 public synchronized Object getImplData() 
{
        return _impl;
}

 public Object getImplData(int field) 
{
        return getExtraFieldData(field, true);
}

 public Object getIntermediate(int field) 
{
        return getExtraFieldData(field, false);
}

 Object getLoadVersion() 
{
        return _loadVersion;
}

 public BitSet getLoaded() 
{
        return _loaded;
}

 public Object getLock() 
{
        return _lock;
}

 public Object getManagedInstance() 
{
        if (_pc instanceof ManagedInstanceProvider)
            return ((ManagedInstanceProvider) _pc).getManagedInstance();
        else
            return _pc;
}

 public ClassMetaData getMetaData() 
{
        return _meta;
}

 public Object getObjectId() 
{
        StateManagerImpl sm = this;
        while (sm.getOwner() != null)
            sm = (StateManagerImpl) sm.getOwner();
        return sm._oid;
}

 public OpenJPAStateManager getOwner() 
{
        return _owner;
}

 public int getOwnerIndex() 
{
        return _ownerIndex;
}

 public Object getPCPrimaryKey(Object oid,
    int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        Object pk = ApplicationIds.get(oid, fmd);
        if (pk == null)
            return null;
        ClassMetaData relmeta = fmd.getDeclaredTypeMetaData();
        if (relmeta.getIdentityType() == ClassMetaData.ID_DATASTORE
            && fmd.getObjectIdFieldTypeCode() == JavaTypes.LONG)
            pk = _broker.getStoreManager().newDataStoreId(pk, relmeta);
        else if (relmeta.getIdentityType() == ClassMetaData.ID_APPLICATION 
            && fmd.getObjectIdFieldType() != relmeta.getObjectIdType())
            pk = ApplicationIds.fromPKValues(new Object[] { pk }, relmeta);
        return _broker.find(pk, false, null);
}

 public PCState getPCState() 
{
        return _state;
}

 public PersistenceCapable getPersistenceCapable() 
{
        return _pc;
}

 public SaveFieldManager getSaveFieldManager() 
{
        return _saved;
}

 public BitSet getUnloaded(FetchConfiguration fetch) 
{
        // collect fields to load from data store based on fetch configuration
        BitSet fields = getUnloadedInternal(fetch, LOAD_FGS, null);
        return (fields == null) ? new BitSet(0) : fields;
}

 public Object getVersion() 
{
        return _version;
}

 public  void initialize(Class cls,
    PCState state) 
{
        // check to see if our current object id instance is the
        // correct id type for the specified class; this is for cases
        // when we have an application id hierarchy and we had set the
        // metadata to a superclass id -- the subclass' id may be a
        // different class, so we need to reset it
        if (_meta.getDescribedType() != cls) {
            ClassMetaData sub = _meta.getRepository().getMetaData
                (cls, _broker.getClassLoader(), true);
            if (_oid != null) {
                if (_meta.getIdentityType() == ClassMetaData.ID_DATASTORE)
                    _oid = _broker.getStoreManager().copyDataStoreId(_oid,
                        sub);
                else if (_meta.isOpenJPAIdentity())
                    _oid = ApplicationIds.copy(_oid, sub);
                else if (sub.getObjectIdType() != _meta.getObjectIdType()) {
                    Object[] pkFields = ApplicationIds.toPKValues(_oid, _meta);
                    _oid = ApplicationIds.fromPKValues(pkFields, sub);
                }
            }
            _meta = sub;
        }
        PersistenceCapable inst = PCRegistry.newInstance(cls, this, _oid, true);
        if (inst == null) {
            // the instance was null: check to see if the instance is
            // abstract (as can sometimes be the case when the
            // class discriminator strategy is not configured correctly)
            if (Modifier.isAbstract(cls.getModifiers()))
                throw new UserException(_loc.get("instantiate-abstract",
                    cls.getName(), _oid));
            throw new InternalException();
        }
        initialize(inst, state);
}

 protected  void initialize(PersistenceCapable pc,
    PCState state) 
{
        if (pc == null)
            throw new UserException(_loc.get("init-null-pc", _meta));
        if (pc.pcGetStateManager() != null && pc.pcGetStateManager() != this)
            throw new UserException(_loc.get("init-sm-pc",
                Exceptions.toString(pc))).setFailedObject(pc);
        pc.pcReplaceStateManager(this);
        FieldMetaData[] fmds = _meta.getFields();
        _loaded = new BitSet(fmds.length);
        _flush = new BitSet(fmds.length);
        _dirty = new BitSet(fmds.length);
        for (int i = 0; i <  fmds.length; i++) {
            // mark primary key and non-persistent fields as loaded
            if (fmds[i].isPrimaryKey()
                || fmds[i].getManagement() != fmds[i].MANAGE_PERSISTENT)
                _loaded.set(i);
            // record whether there are any managed inverse fields
            if (_broker.getInverseManager() != null
                && fmds[i].getInverseMetaDatas().length  > 0)
                _flags |= FLAG_INVERSES;
        }
        pc.pcSetDetachedState(null);
        _pc = pc;
        if (_oid instanceof OpenJPAId)
            ((OpenJPAId) _oid).setManagedInstanceType(_meta.getDescribedType());
        // initialize our state and add ourselves to the broker's cache
        setPCState(state);
        _broker.setStateManager(_id, this, BrokerImpl.STATUS_INIT);
        if (state == PCState.PNEW)
            fireLifecycleEvent(LifecycleEvent.AFTER_PERSIST);
        // if this is a non-tracking PC, add a hard ref to the appropriate data
        // sets and give it an opportunity to make a state snapshot.
        if (!isIntercepting()) {
            saveFields(true);
            if (!isNew())
                RedefinitionHelper.assignLazyLoadProxies(this);
        }
}

Initialize with the given instance and state.

 public boolean isDefaultValue(int field) 
{
        lock();
        try {
            _single.clear();
            provideField(_pc, _single, field);
            boolean ret = _single.isDefaultValue();
            _single.clear();
            return ret;
        } finally {
            unlock();
        }
}

 public boolean isDeleted() 
{
        return _state.isDeleted();
}

 public boolean isDetached() 
{
        return (_flags & FLAG_DETACHING) != 0;
}

 public boolean isDirty() 
{
        return _state.isDirty();
}

 public boolean isEmbedded() 
{
        return _owner != null;
}

 public boolean isFlushed() 
{
        return (_flags & FLAG_FLUSHED)  > 0;
}

 public boolean isFlushedDirty() 
{
        return (_flags & FLAG_FLUSHED_DIRTY)  > 0;
}

 public boolean isImplDataCacheable() 
{
        return (_flags & FLAG_IMPL_CACHE) != 0;
}

 public synchronized boolean isImplDataCacheable(int field) 
{
        if (_fieldImpl == null || !_loaded.get(field))
            return false;
        if (_meta.getField(field).usesImplData() != null)
            return false;
        int idx = _meta.getExtraFieldDataIndex(field);
        return idx != -1 && _fieldImpl[idx] != null;
}

 public boolean isIntercepting() 
{
        if (getMetaData().isIntercepting())
            return true;
        if (getMetaData().getAccessType() != ClassMetaData.ACCESS_FIELD
            && _pc instanceof DynamicPersistenceCapable)
            return true;
        return false;
}

Whether or not data access in this instance is intercepted. This differs from ClassMetaData#isIntercepting() in that it checks for property access + subclassing in addition to the redefinition / enhancement checks.

 boolean isLoading() 
{
        return (_flags & FLAG_LOADING)  > 0;
}

Whether this state manager is in the middle of a load.

 public boolean isNew() 
{
        return _state.isNew();
}

 public boolean isPendingTransactional() 
{
        return _state.isPendingTransactional();
}

 public boolean isPersistent() 
{
        return _state.isPersistent();
}

 public boolean isProvisional() 
{
        return _state.isProvisional();
}

 public boolean isTransactional() 
{
        // special case for TCLEAN, which we want to appear non-trans to
        // internal code, but which publicly should be transactional
        return _state == PCState.TCLEAN || _state.isTransactional();
}

 public boolean isVersionCheckRequired() 
{
        // explicit flag for version check
        if ((_flags & FLAG_VERSION_CHECK) != 0)
            return true;
        if (!_broker.getOptimistic() && !_broker.getConfiguration().
            getCompatibilityInstance().getNonOptimisticVersionCheck())
            return false;
        return _state.isVersionCheckRequired(this);
}

Returns whether this instance needs a version check.

 public boolean isVersionUpdateRequired() 
{
        return (_flags & FLAG_VERSION_UPDATE)  > 0;
}

Returns whether this instance needs a version update.

 public  void load(FetchConfiguration fetch) 
{
        load(fetch, LOAD_FGS, null, null, false);
}

 protected boolean load(FetchConfiguration fetch,
    int loadMode,
    BitSet exclude,
    Object sdata,
    boolean forWrite) 
{
        if (!forWrite && (!isPersistent() || isNew() || isDeleted()))
            return false;
        // if any fields being loaded, do state transitions for read
        BitSet fields = getUnloadedInternal(fetch, loadMode, exclude);
        boolean active = _broker.isActive();
        if (!forWrite && fields != null)
            beforeRead(-1);
        // call load even if no fields are being loaded, because it takes
        // care of checking if the DFG is loaded, making sure version info
        // is loaded, etc
        int lockLevel = calculateLockLevel(active, forWrite, fetch);
        boolean ret = loadFields(fields, fetch, lockLevel, sdata);
        obtainLocks(active, forWrite, lockLevel, fetch, sdata);
        return ret;
}

Load the state of this instance based on the given fetch configuration and load mode. Return true if any data was loaded, false otherwise.

 protected  void loadField(int field,
    int lockLevel,
    boolean forWrite,
    boolean fgs) 
{
        FetchConfiguration fetch = _broker.getFetchConfiguration();
        FieldMetaData fmd = _meta.getField(field);
        BitSet fields = null;
        // if this is a dfg field or we need to load our dfg, do so
        if (fgs && (_flags & FLAG_LOADED) == 0)
            fields = getUnloadedInternal(fetch, LOAD_FGS, null);
        // check for load fetch group
        String lfg = fmd.getLoadFetchGroup();
        boolean lfgAdded = false;
        if (lfg != null) {  
            FieldMetaData[] fmds = _meta.getFields();
            for (int i = 0; i <  fmds.length; i++) {
                if (!_loaded.get(i) && (i == field
                    || fmds[i].isInFetchGroup(lfg))) {
                    if (fields == null)
                        fields = new BitSet(fmds.length);
                    fields.set(i);
                }
            }
            // relation field is loaded with the load-fetch-group
            // but this addition must be reverted once the load is over
            if (!fetch.hasFetchGroup(lfg)) {
                fetch.addFetchGroup(lfg);
                lfgAdded = true;
            }
        } else if (fmd.isInDefaultFetchGroup() && fields == null) {
            // no load group but dfg: add dfg fields if we haven't already
            fields = getUnloadedInternal(fetch, LOAD_FGS, null);
        } else if (!_loaded.get(fmd.getIndex())) {
            // no load group or dfg: load individual field
            if (fields == null)
                fields = new BitSet();
            fields.set(fmd.getIndex());
        }
        // call this method even if there are no unloaded fields; loadFields
        // takes care of things like loading version info and setting PC flags
        try {
            loadFields(fields, fetch, lockLevel, null);
        } finally {
            if (lfgAdded)
                fetch.removeFetchGroup(lfg);
        }
}

Load the given field's fetch group; the field itself may already be loaded if it is being set by the user.

 boolean loadFields(BitSet fields,
    FetchConfiguration fetch,
    int lockLevel,
    Object sdata) 
{
        // can't load version field from store
        if (fields != null) {
            FieldMetaData vfield = _meta.getVersionField();
            if (vfield != null)
                fields.clear(vfield.getIndex());
        }
        boolean ret = false;
        setLoading(true);
        try {
            // if any fields given, load them
            int len = (fields == null) ? 0 : fields.length();
            if (len  > 0) {
                if (fetch == null)
                    fetch = _broker.getFetchConfiguration();
                if (!_broker.getStoreManager().load(this, fields, fetch,
                    lockLevel, sdata)) {
                    throw new ObjectNotFoundException(_loc.get("del-instance",
                        _meta.getDescribedType(), _oid)).
                        setFailedObject(getManagedInstance());
                }
                ret = true;
            }
            // make sure version information has been set; version info must
            // always be set after the first state load or set (which is why
            // we do this even if no fields were loaded -- could be that this
            // method is being called after a field is set)... some instances
            // might not have version info, in which case this gets called
            // mutiple times; that should be ok too
            if (_loadVersion == null) {
                syncVersion(sdata);
                ret = ret || _loadVersion != null;
            }
        }
        finally {
            setLoading(false);
        }
        // see if the dfg is now loaded; do this regardless of whether we
        // loaded any fields, cause may already have been loaded by
        // StoreManager during initialization
        postLoad(-1, fetch);
        return ret;
}

Load the given field set from the data store into the instance. Return true if any data is loaded, false otherwise.

 protected  void lock() 
{
        // use broker-level lock to avoid deadlock situations with the state
        // manager lock and broker lock being obtained in different orders
        _broker.lock();
}

Lock the state manager if the multithreaded option is set.

 public Object newFieldProxy(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        ProxyManager mgr = _broker.getConfiguration().
            getProxyManagerInstance();
        Object init = fmd.getInitializer();
        switch (fmd.getDeclaredTypeCode()) {
            case JavaTypes.DATE:
                return mgr.newDateProxy(fmd.getDeclaredType());
            case JavaTypes.CALENDAR:
                return mgr.newCalendarProxy(fmd.getDeclaredType(),
                    init instanceof TimeZone ? (TimeZone) init : null);
            case JavaTypes.COLLECTION:
                return mgr.newCollectionProxy(fmd.getProxyType(),
                    fmd.getElement().getDeclaredType(),
                    init instanceof Comparator ? (Comparator) init : null);
            case JavaTypes.MAP:
                return mgr.newMapProxy(fmd.getProxyType(),
                    fmd.getKey().getDeclaredType(),
                    fmd.getElement().getDeclaredType(),
                    init instanceof Comparator ? (Comparator) init : null);
        }
        return null;
}

 public Object newProxy(int field) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            return newFieldProxy(field);
        switch (fmd.getTypeCode()) {
            case JavaTypes.DATE:
                if (fmd.getDeclaredType() == java.sql.Date.class)
                    return new java.sql.Date(System.currentTimeMillis());
                if (fmd.getDeclaredType() == java.sql.Timestamp.class)
                    return new java.sql.Timestamp(System.currentTimeMillis());
                if (fmd.getDeclaredType() == java.sql.Time.class)
                    return new java.sql.Time(System.currentTimeMillis());
                return new Date();
            case JavaTypes.CALENDAR:
                return Calendar.getInstance();
            case JavaTypes.COLLECTION:
                return new ArrayList();
            case JavaTypes.MAP:
                return new HashMap();
        }
        return null;
}

  void nonprovisional(boolean logical,
    OpCallbacks call) 
{
        setPCState(_state.nonprovisional(this, logical, call));
}

Delegates to the current state.

  void nontransactional() 
{
        setPCState(_state.nontransactional(this));
}

Delegates to the current state.

  void persist() 
{
        setPCState(_state.persist(this));
}

Delegates to the current state.

  void preDelete() 
{
        // set a flag while call pre delete callback so that user can't
        // get into infinite recursion by calling delete(this)
        // within his callback method
        if ((_flags & FLAG_PRE_DELETING) == 0) {
            _flags |= FLAG_PRE_DELETING;
            try {
                fireLifecycleEvent(LifecycleEvent.BEFORE_DELETE);
            } finally {
                _flags &= ~FLAG_PRE_DELETING;
            }
        }
}

Make callbacks for deletion.

  void preFlush(boolean logical,
    OpCallbacks call) 
{
        if ((_flags & FLAG_PRE_FLUSHED) != 0)
            return;
        if (isPersistent()) {
            fireLifecycleEvent(LifecycleEvent.BEFORE_STORE);
            // BEFORE_PERSIST is handled during Broker.persist and Broker.attach
            if (isDeleted())
                fireLifecycleEvent(LifecycleEvent.BEFORE_DELETE);
            else if (!(isNew() && !isFlushed()))
                fireLifecycleEvent(LifecycleEvent.BEFORE_UPDATE);
            _flags |= FLAG_PRE_FLUSHED;
        }
        lock();
        try {
            if (!logical)
                assignObjectId(false, true);
            for (int i = 0, len = _meta.getFields().length; i <  len; i++) {
                if ((logical || !assignField(i, true)) && !_flush.get(i)
                    && _dirty.get(i)) {
                    provideField(_pc, _single, i);
                    if (_single.preFlush(logical, call))
                        replaceField(_pc, _single, i);
                    else
                        _single.clear();
                }
            }
            dirtyCheck();
        } finally {
            unlock();
        }
}

Get ready for a flush. Persists all persistence-capable object fields, and checks for illegal null values. Also assigns oids and field values for all strategies that don't require flushing.

  void provideField(PersistenceCapable pc,
    FieldManager store,
    int field) 
{
        FieldManager beforeFM = _fm;
        _fm = store;
        pc.pcProvideField(field);
        // Retaining original FM because of the possibility of reentrant calls
        _fm = beforeFM;
}

Helper method to provide the given field number to the given field manager.

 public  void providedBooleanField(PersistenceCapable pc,
    int field,
    boolean curVal) 
{
        _fm.storeBooleanField(field, curVal);
}

 public  void providedByteField(PersistenceCapable pc,
    int field,
    byte curVal) 
{
        _fm.storeByteField(field, curVal);
}

 public  void providedCharField(PersistenceCapable pc,
    int field,
    char curVal) 
{
        _fm.storeCharField(field, curVal);
}

 public  void providedDoubleField(PersistenceCapable pc,
    int field,
    double curVal) 
{
        _fm.storeDoubleField(field, curVal);
}

 public  void providedFloatField(PersistenceCapable pc,
    int field,
    float curVal) 
{
        _fm.storeFloatField(field, curVal);
}

 public  void providedIntField(PersistenceCapable pc,
    int field,
    int curVal) 
{
        _fm.storeIntField(field, curVal);
}

 public  void providedLongField(PersistenceCapable pc,
    int field,
    long curVal) 
{
        _fm.storeLongField(field, curVal);
}

 public  void providedObjectField(PersistenceCapable pc,
    int field,
    Object curVal) 
{
        _fm.storeObjectField(field, curVal);
}

 public  void providedShortField(PersistenceCapable pc,
    int field,
    short curVal) 
{
        _fm.storeShortField(field, curVal);
}

 public  void providedStringField(PersistenceCapable pc,
    int field,
    String curVal) 
{
        _fm.storeStringField(field, curVal);
}

 public  void proxyDetachedDeserialized(int idx) 
{
        // we don't serialize state manager impls
        throw new InternalException();
}

  void proxyFields(boolean reset,
    boolean replaceNull) 
{
        // we only replace nulls if the runtime can't differentiate between
        // null and empty containers.  we replace nulls in this case to
        // maintain consistency whether values are being retained or not
        if (replaceNull)
            replaceNull = !_broker.getConfiguration().supportedOptions().
                contains(OpenJPAConfiguration.OPTION_NULL_CONTAINER);
        lock();
        try {
            for (int i = 0, len = _loaded.length(); i <  len; i++) {
                if (_loaded.get(i)) {
                    provideField(_pc, _single, i);
                    if (_single.proxy(reset, replaceNull))
                        replaceField(_pc, _single, i);
                    else
                        _single.clear();
                }
            }
        } finally {
            unlock();
        }
}

Replaces all second class object fields with fresh proxied instances containing the same information as the originals.

  void readLocked(int readLockLevel,
    int writeLockLevel) 
{
        // make sure object is added to transaction so lock will get
        // cleared on commit/rollback
        if (readLockLevel != LockLevels.LOCK_NONE)
            transactional();
        _readLockLevel = readLockLevel;
        _writeLockLevel = writeLockLevel;
        _flags |= FLAG_READ_LOCKED;
        _flags &= ~FLAG_WRITE_LOCKED;
}

Notification that we've been read-locked. Pass in the level at which we were locked and the level at which we should write lock ourselves on dirty.

 PersistenceCapable readPC(ObjectInputStream in) throws IOException, ClassNotFoundException 
{
        Object o = in.readObject();
        if (o == null)
            return null;
        PersistenceCapable pc;
        if (!(o instanceof PersistenceCapable))
            pc = ImplHelper.toPersistenceCapable(o, this);
        else
            pc = (PersistenceCapable) o;
        pc.pcReplaceStateManager(this);
        return pc;
}

Converts the deserialized o to a PersistenceCapable instance appropriate for storing in _pc.

  void release(boolean unproxy) 
{
        release(unproxy, false);
}

Delegates to the current state.

  void release(boolean unproxy,
    boolean force) 
{
        // optimization for detach-in-place special case when fields are
        // already (un)proxied correctly
        if (!unproxy)
            _flags |= FLAG_NO_UNPROXY;
        try {
            if (force)
                setPCState(PCState.TRANSIENT);
            else
                setPCState(_state.release(this));
        } finally {
            _flags &= ~FLAG_NO_UNPROXY;
        }
}

 public  void removed(int field,
    Object removed,
    boolean key) 
{
        if (removed == null)
            return;
        try {
            // dereference dependent fields, delete embedded
            FieldMetaData fmd = _meta.getField(field);
            ValueMetaData vmd = (key) ? fmd.getKey() : fmd.getElement();
            if (vmd.isEmbeddedPC())
                _single.delete(vmd, removed, null);
            else if (vmd.getCascadeDelete() == ValueMetaData.CASCADE_AUTO)
                _single.dereferenceDependent(removed);
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

 public boolean replaceBooleanField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchBooleanField(field);
}

 public byte replaceByteField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchByteField(field);
}

 public char replaceCharField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchCharField(field);
}

 public double replaceDoubleField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchDoubleField(field);
}

  void replaceField(PersistenceCapable pc,
    FieldManager load,
    int field) 
{
        FieldManager beforeFM = _fm;
        _fm = load;
        pc.pcReplaceField(field);
        // Retaining original FM because of the possibility of reentrant calls
        _fm = beforeFM;
}

Helper method to replace the given field number to the given field manager.

 public byte replaceFlags() 
{
        // we always use load required so that we can detect when objects
        // are touched for locking or making transactional
        return PersistenceCapable.LOAD_REQUIRED;
}

 public float replaceFloatField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchFloatField(field);
}

 public int replaceIntField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchIntField(field);
}

 public long replaceLongField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchLongField(field);
}

 public Object replaceObjectField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchObjectField(field);
}

 public short replaceShortField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchShortField(field);
}

 public StateManager replaceStateManager(StateManager sm) 
{
        return sm;
}

 public String replaceStringField(PersistenceCapable pc,
    int field) 
{
        return _fm.fetchStringField(field);
}

  void restoreFields() 
{
        lock();
        try {
            if (_saved == null) {
                if ((_flags & FLAG_SAVE) == 0)
                    clearFields();
                else // only unloaded fields were dirtied
                    _loaded.andNot(_loaded);
            }
            // we direct state transitions based on our own getRestoreState
            // method, but to decide whether to actually rollback field
            // values, we consult the broker for the user's setting
            else if (_broker.getRestoreState() != RestoreState.RESTORE_NONE) {
                // rollback all currently-loaded fields
                for (int i = 0, len = _loaded.length(); i <  len; i++)
                    if (_loaded.get(i) && _saved.restoreField(i))
                        replaceField(_pc, _saved, i);
                // rollback loaded set
                _loaded.andNot(_saved.getUnloaded());
            }
        }
        finally {
            unlock();
        }
}

Rollback the state of the instance to the saved state from the last call to #saveFields , or to default values if never saved.

  void rollback() 
{
        // release locks
        releaseLocks();
        _flags &= ~FLAG_FLUSHED;
        _flags &= ~FLAG_FLUSHED_DIRTY;
        afterFlush(BrokerImpl.FLUSH_ROLLBACK);
        if (_broker.getRestoreState() != RestoreState.RESTORE_NONE)
            setPCState(_state.rollbackRestore(this));
        else
            setPCState(_state.rollback(this));
}

Delegates to the current state after checking the value of the RetainState flag.

  void rollbackToSavepoint(SavepointFieldManager savepoint) 
{
        _state = savepoint.getPCState();
        BitSet loaded = savepoint.getLoaded();
        for (int i = 0, len = loaded.length(); i <  len; i++) {
            if (loaded.get(i) && savepoint.restoreField(i)) {
                provideField(savepoint.getCopy(), savepoint, i);
                replaceField(_pc, savepoint, i);
            }
        }
        _loaded = loaded;
        _dirty = savepoint.getDirty();
        _flush = savepoint.getFlushed();
        _version = savepoint.getVersion();
        _loadVersion = savepoint.getLoadVersion();
}

Rollback state of the managed instance to the given savepoint.

  void saveFields(boolean immediate) 
{
        if (_broker.getRestoreState() == RestoreState.RESTORE_NONE
            && (_flags & FLAG_INVERSES) == 0)
            return;
        _flags |= FLAG_SAVE;
        if (immediate) {
            for (int i = 0, len = _loaded.length(); i <  len; i++)
                saveField(i);
            _flags &= ~FLAG_SAVE;
        }
}

Record that we should save any fields that change from this point forward.

 public boolean serializing() 
{
        // if the broker is in the midst of a serialization, then no special
        // handling should be performed on the instance, and no subsequent
        // load should happen
        if (_broker.isSerializing())
            return false;
        try {
            if (_meta.isDetachable())
                return DetachManager.preSerialize(this);
            load(_broker.getFetchConfiguration(), LOAD_SERIALIZE, null, null, 
                false);
            return false;
        } catch (RuntimeException re) {
            throw translate(re);
        }
}

  void setCheckVersion(boolean versionCheck) 
{
        if (versionCheck)
            _flags |= FLAG_VERSION_CHECK;
        else
            _flags &= ~FLAG_VERSION_CHECK;
}

Set whether this instance requires a version check on the next flush.

  void setDereferencedDependent(boolean deref,
    boolean notify) 
{
        if (!deref && (_flags & FLAG_DEREF)  > 0) {
            if (notify)
                _broker.removeDereferencedDependent(this);
            _flags &= ~FLAG_DEREF;
        } else if (deref && (_flags & FLAG_DEREF) == 0) {
            _flags |= FLAG_DEREF;
            if (notify)
                _broker.addDereferencedDependent(this);
        }
}

Mark this object as a dereferenced dependent object.

  void setDirty(boolean val) 
{
        FieldMetaData[] fmds = _meta.getFields();
        boolean update = !isNew() || isFlushed();
        for (int i = 0; i <  fmds.length; i++) {
            if (val && (!update
                || fmds[i].getUpdateStrategy() != UpdateStrategies.IGNORE))
                _dirty.set(i);
            else if (!val) {
                // we never consider clean fields flushed; this also takes
                // care of clearing the flushed fields on commit/rollback
                _flush.clear(i);
                _dirty.clear(i);
            }
        }
        if (val)
            _flags |= FLAG_LOADED;
}

Records that all instance fields are/are not dirty, and changes the flags of the instance accordingly.

 public synchronized Object setImplData(Object data,
    boolean cacheable) 
{
        Object old = _impl;
        _impl = data;
        if (cacheable && data != null)
            _flags |= FLAG_IMPL_CACHE;
        else
            _flags &= ~FLAG_IMPL_CACHE;
        return old;
}

 public Object setImplData(int field,
    Object data) 
{
        return setExtraFieldData(field, data, true);
}

 public  void setIntermediate(int field,
    Object data) 
{
        setExtraFieldData(field, data, false);
}

  void setLoaded(boolean val) 
{
        FieldMetaData[] fmds = _meta.getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (!fmds[i].isPrimaryKey()
                && fmds[i].getManagement() == fmds[i].MANAGE_PERSISTENT)
                setLoaded(i, val);
        }
        if (!val) {
            _flags &= ~FLAG_LOADED;
            setDirty(false);
        } else
            _flags |= FLAG_LOADED;
}

Records that all instance fields are/are not loaded. Primary key and non-persistent fields are not affected.

  void setLoading(boolean loading) 
{
        if (loading)
            _flags |= FLAG_LOADING;
        else
            _flags &= ~FLAG_LOADING;
}

Whether this state manager is in the middle of a load initiated by outside code; for any internal methods that cause loading, the loading flag is set automatically.

 public  void setLock(Object lock) 
{
        _lock = lock;
}

 public  void setNextVersion(Object version) 
{
        assignVersionField(version);
}

 public  void setObjectId(Object oid) 
{
        _oid = oid;
        if (_pc != null && oid instanceof OpenJPAId)
            ((OpenJPAId) oid).setManagedInstanceType(_meta.getDescribedType());
}

  void setOwner(StateManagerImpl owner,
    ValueMetaData ownerMeta) 
{
        _owner = owner;
        _ownerIndex = ownerMeta.getFieldMetaData().getIndex();
}

Set the owning state and field if this is an embedded instance.

 public  void setRemote(int field,
    Object value) 
{
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, false);
            storeField(field, value, _single);
            replaceField(_pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

  void setUpdateVersion(boolean versionUpdate) 
{
        if (versionUpdate)
            _flags |= FLAG_VERSION_UPDATE;
        else
            _flags &= ~FLAG_VERSION_UPDATE;
}

Set whether this instance requires a version update on the next flush.

 public  void setVersion(Object version) 
{
        _loadVersion = version;
        assignVersionField(version);
}

 public  void settingBooleanField(PersistenceCapable pc,
    int field,
    boolean curVal,
    boolean newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeBooleanField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingByteField(PersistenceCapable pc,
    int field,
    byte curVal,
    byte newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeByteField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingCharField(PersistenceCapable pc,
    int field,
    char curVal,
    char newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeCharField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingDoubleField(PersistenceCapable pc,
    int field,
    double curVal,
    double newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeDoubleField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingFloatField(PersistenceCapable pc,
    int field,
    float curVal,
    float newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeFloatField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingIntField(PersistenceCapable pc,
    int field,
    int curVal,
    int newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeIntField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingLongField(PersistenceCapable pc,
    int field,
    long curVal,
    long newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeLongField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingObjectField(PersistenceCapable pc,
    int field,
    Object curVal,
    Object newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            FieldMetaData fmd = _meta.getField(field);
            if (_loaded.get(field)) {
                if (newVal == curVal)
                    return;
                // only compare new to old values if the comparison is going to
                // be cheap -- don't compare collections, maps, UDTs
                switch (fmd.getDeclaredTypeCode()) {
                    case JavaTypes.ARRAY:
                    case JavaTypes.COLLECTION:
                    case JavaTypes.MAP:
                    case JavaTypes.PC:
                    case JavaTypes.PC_UNTYPED:
                        break;
                    default:
                        if (newVal != null && newVal.equals(curVal))
                            return;
                }
            } else {
                // if this is a dependent unloaded field, make sure to load
                // it now
                if (fmd.getCascadeDelete() == ValueMetaData.CASCADE_AUTO
                    || fmd.getKey().getCascadeDelete()
                    == ValueMetaData.CASCADE_AUTO
                    || fmd.getElement().getCascadeDelete()
                    == ValueMetaData.CASCADE_AUTO)
                    curVal = fetchObjectField(field);
            }
            assertNoPrimaryKeyChange(field);
            if (fmd.getDeclaredTypeCode() == JavaTypes.OID)
                assertNotManagedObjectId(newVal);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            if (set != SET_REMOTE) {
                _single.storeObjectField(field, curVal);
                _single.unproxy();
                _single.dereferenceDependent();
                _single.clear();
            }
            _single.storeObjectField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingShortField(PersistenceCapable pc,
    int field,
    short curVal,
    short newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (newVal == curVal && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeShortField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void settingStringField(PersistenceCapable pc,
    int field,
    String curVal,
    String newVal,
    int set) 
{
        if (set != SET_REMOTE) {
            if (StringUtils.equals(newVal, curVal) && _loaded.get(field))
                return;
            assertNoPrimaryKeyChange(field);
        }
        lock();
        try {
            Boolean stat = dirty(field, Boolean.FALSE, set == SET_USER);
            _single.storeStringField(field, newVal);
            replaceField(pc, _single, field);
            postDirty(stat);
        } finally {
            unlock();
        }
}

 public  void store(int field,
    Object val) 
{
        val = _meta.getField(field).getFieldValue(val, _broker);
        storeField(field, val);
}

 public  void storeBoolean(int field,
    boolean externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeBooleanField(field, externalVal);
        else {
            Object val = (externalVal) ? Boolean.TRUE : Boolean.FALSE;
            storeField(field, fmd.getFieldValue(val, _broker));
        }
}

 public  void storeBooleanField(int field,
    boolean curVal) 
{
        lock();
        try {
            _single.storeBooleanField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeByte(int field,
    byte externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeByteField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(new Byte(externalVal),
                _broker));
}

 public  void storeByteField(int field,
    byte curVal) 
{
        lock();
        try {
            _single.storeByteField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeChar(int field,
    char externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeCharField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(new Character(externalVal),
                _broker));
}

 public  void storeCharField(int field,
    char curVal) 
{
        lock();
        try {
            _single.storeCharField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeDouble(int field,
    double externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeDoubleField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(new Double(externalVal),
                _broker));
}

 public  void storeDoubleField(int field,
    double curVal) 
{
        lock();
        try {
            _single.storeDoubleField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeField(int field,
    Object val) 
{
        storeField(field, val, this);
}

 public  void storeFloat(int field,
    float externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeFloatField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(new Float(externalVal),
                _broker));
}

 public  void storeFloatField(int field,
    float curVal) 
{
        lock();
        try {
            _single.storeFloatField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeInt(int field,
    int externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeIntField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(Numbers.valueOf(externalVal),
                _broker));
}

 public  void storeIntField(int field,
    int curVal) 
{
        lock();
        try {
            _single.storeIntField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeLong(int field,
    long externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeLongField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(Numbers.valueOf(externalVal),
                _broker));
}

 public  void storeLongField(int field,
    long curVal) 
{
        lock();
        try {
            _single.storeLongField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeObject(int field,
    Object externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        externalVal = fmd.order(externalVal);
        if (!fmd.isExternalized())
            storeObjectField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(externalVal, _broker));
}

 public  void storeObjectField(int field,
    Object curVal) 
{
        lock();
        try {
            _single.storeObjectField(field, curVal);
            _single.proxy(true, false);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeShort(int field,
    short externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeShortField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(new Short(externalVal),
                _broker));
}

 public  void storeShortField(int field,
    short curVal) 
{
        lock();
        try {
            _single.storeShortField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

 public  void storeString(int field,
    String externalVal) 
{
        FieldMetaData fmd = _meta.getField(field);
        if (!fmd.isExternalized())
            storeStringField(field, externalVal);
        else
            storeField(field, fmd.getFieldValue(externalVal, _broker));
}

 public  void storeStringField(int field,
    String curVal) 
{
        lock();
        try {
            _single.storeStringField(field, curVal);
            replaceField(_pc, _single, field);
            setLoaded(field, true);
            postLoad(field, null);
        } finally {
            unlock();
        }
}

  void transactional() 
{
        setPCState(_state.transactional(this));
}

Delegates to the current state.

 protected RuntimeException translate(RuntimeException re) 
{
        RuntimeExceptionTranslator trans = _broker.
            getInstanceExceptionTranslator();
        return (trans == null) ? re : trans.translate(re);
}

Translate the given exception based on the broker's implicit behavior. Translation only occurs if the exception is initiated by a user action on an instance, and therefore will not be caught and translated by the broker.

 protected  void unlock() 
{
		// use broker-level lock to avoid deadlock situations with the state 
		// manager lock and broker lock being obtained in different orders
		_broker.unlock ();
}

Unlock the state manager.

  void unproxyFields() 
{
        if ((_flags & FLAG_NO_UNPROXY) != 0)
            return;
        lock();
        try {
            for (int i = 0, len = _loaded.length(); i <  len; i++) {
                provideField(_pc, _single, i);
                _single.unproxy();
                _single.releaseEmbedded();
                _single.clear();
            }
        }
        finally {
            unlock();
        }
}

Unproxy all fields.

 public boolean writeDetached(ObjectOutput out) throws IOException 
{
        BitSet idxs = new BitSet(_meta.getFields().length);
        lock();
        try {
            boolean detsm = DetachManager.writeDetachedState(this, out, idxs);
            if (detsm)
                _flags |= FLAG_DETACHING;
            FieldMetaData[] fmds = _meta.getFields();
            for (int i = 0; i <  fmds.length; i++) {
                if (fmds[i].isTransient())
                    continue;
                provideField(_pc, _single, i);
                _single.serialize(out, !idxs.get(i));
                _single.clear();
            }
            return true;
        } catch (RuntimeException re) {
            throw translate(re);
        } finally {
            _flags &= ~FLAG_DETACHING;
            unlock();
        }
}

  void writePC(ObjectOutputStream oos,
    PersistenceCapable pc) throws IOException 
{
        if (!Serializable.class.isAssignableFrom(_meta.getDescribedType()))
            throw new NotSerializableException(
                _meta.getDescribedType().getName());
        oos.writeObject(pc);
}

Write pc to oos, handling internal-form serialization. pc must be of the same type that this state manager manages.