public PCDataImpl(Object oid,
    ClassMetaData meta) 
{
          
        _oid = oid;
        _type = meta.getDescribedType();
        int len = meta.getFields().length;
        _data = new Object[len];
        _loaded = new BitSet(len);
}

Constructor.

 public  void clearData(int index) 
{
        _loaded.clear(index);
        _data[index] = null;
}

 public Object getData(int index) 
{
        // make sure index is actually loaded to avoid returning an
        // intermediate value
        return (_loaded.get(index)) ? _data[index] : null;
}

 public Object getId() 
{
        return _oid;
}

 public Object getImplData() 
{
        return _impl;
}

 public Object getImplData(int index) 
{
        return (_fieldImpl != null) ? _fieldImpl[index] : null;
}

 public Object getIntermediate(int index) 
{
        return (!_loaded.get(index)) ? _data[index] : null;
}

 public BitSet getLoaded() 
{
        return _loaded;
}

 public Class getType() 
{
        return _type;
}

 public Object getVersion() 
{
        return _version;
}

 public boolean isLoaded(int index) 
{
        return _loaded.get(index);
}

 public  void load(OpenJPAStateManager sm,
    FetchConfiguration fetch,
    Object context) 
{
        loadVersion(sm);
        loadImplData(sm);
        FieldMetaData[] fmds = sm.getMetaData().getFields();
        ((StateManagerImpl)sm).setLoading(true);
        for (int i = 0; i <  fmds.length; i++) {
            // load intermediate data for all unloaded fields and data for
            // fields in configured fetch groups
            if (!isLoaded(i))
                loadIntermediate(sm, fmds[i]);
            else if (!sm.getLoaded().get(i) && fetch.requiresFetch(fmds[i]) 
                != FetchConfiguration.FETCH_NONE)
                loadField(sm, fmds[i], fetch, context);
        }
}

 public  void load(OpenJPAStateManager sm,
    BitSet fields,
    FetchConfiguration fetch,
    Object context) 
{
        loadVersion(sm);
        loadImplData(sm);
        // attempt to load given fields
        int len = (fields == null) ? 0 : fields.length();
        FieldMetaData fmd;
        for (int i = 0; i <  len; i++) {
            if (!fields.get(i))
                continue;
            fmd = sm.getMetaData().getField(i);
            if (!isLoaded(i))
                loadIntermediate(sm, fmd);
            else {
                loadField(sm, fmd, fetch, context);
                loadImplData(sm, fmd);
                fields.clear(i);
            }
        }
}

 protected  void loadField(OpenJPAStateManager sm,
    FieldMetaData fmd,
    FetchConfiguration fetch,
    Object context) 
{
        int index = fmd.getIndex();
        Object val = toField(sm, fmd, getData(index), fetch, context);
        sm.storeField(index, val);
}

Set field-level information into the given state manager.

 protected  void loadImplData(OpenJPAStateManager sm) 
{
        Object impl = getImplData();
        if (sm.getImplData() == null && impl != null)
            sm.setImplData(impl, true);
}

Set impl data information into the given state manager.

 protected  void loadImplData(OpenJPAStateManager sm,
    FieldMetaData fmd) 
{
        int index = fmd.getIndex();
        Object impl = getImplData(index);
        if (impl != null)
            sm.setImplData(index, impl);
}

Set field-level impl data into the given state manager.

 protected  void loadIntermediate(OpenJPAStateManager sm,
    FieldMetaData fmd) 
{
        int index = fmd.getIndex();
        Object inter = getIntermediate(index);
        if (inter != null && !sm.getLoaded().get(index))
            sm.setIntermediate(index, inter);
}

Set intermediate information for the given field into the state manager.

 protected  void loadVersion(OpenJPAStateManager sm) 
{
        if (sm.getVersion() == null)
            sm.setVersion(getVersion());
}

Set version information into the given state manager.

 public AbstractPCData newEmbeddedPCData(OpenJPAStateManager sm) 
{
        return new PCDataImpl(sm.getId (), sm.getMetaData ());
}

Return a new PCData implementation of the right type for embedded instances. Returns a PCDataImpl by default.

 public  void setData(int index,
    Object val) 
{
        _loaded.set(index);
        _data[index] = val;
}

 public  void setImplData(Object val) 
{
        _impl = val;
}

 public  void setImplData(int index,
    Object val) 
{
        if (val != null) {
            if (_fieldImpl == null)
                _fieldImpl = new Object[_data.length];
            _fieldImpl[index] = val;
        } else if (_fieldImpl != null)
            _fieldImpl[index] = null;
}

 public  void setIntermediate(int index,
    Object val) 
{
        _loaded.clear(index);
        _data[index] = val;
}

 public  void setLoaded(int index,
    boolean loaded) 
{
        if (loaded)
            _loaded.set(index);
        else
            _loaded.clear(index);
}

 public  void setVersion(Object version) 
{
        _version = version;
}

 public  void store(OpenJPAStateManager sm) 
{
        storeVersion(sm);
        storeImplData(sm);
        FieldMetaData[] fmds = sm.getMetaData().getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (sm.getLoaded().get(i)) {
                storeField(sm, fmds[i]);
                storeImplData(sm, fmds[i], isLoaded(i));
            } else if (!isLoaded(i))
                storeIntermediate(sm, fmds[i]);
        }
}

 public  void store(OpenJPAStateManager sm,
    BitSet fields) 
{
        storeVersion(sm);
        storeImplData(sm);
        FieldMetaData[] fmds = sm.getMetaData().getFields();
        for (int i = 0; i <  fmds.length; i++) {
            if (fields != null && fields.get(i)) {
                storeField(sm, fmds[i]);
                storeImplData(sm, fmds[i], isLoaded(i));
            } else if (!isLoaded(i))
                storeIntermediate(sm, fmds[i]);
        }
}

 protected  void storeField(OpenJPAStateManager sm,
    FieldMetaData fmd) 
{
        if (fmd.getManagement() != fmd.MANAGE_PERSISTENT)
            return;
        int index = fmd.getIndex();
        Object val = toData(fmd, sm.fetchField(index, false),
            sm.getContext());
        if (val != NULL)
            setData(index, val);
        else // unable to store field value; clear out any old values
            clearData(index);
}

Store field-level information from the given state manager.

 protected  void storeImplData(OpenJPAStateManager sm) 
{
        if (sm.isImplDataCacheable())
            setImplData(sm.getImplData());
}

Store impl data from the given state manager.

 protected  void storeImplData(OpenJPAStateManager sm,
    FieldMetaData fmd,
    boolean fieldLoaded) 
{
        int index = fmd.getIndex();
        if (fieldLoaded) {
            // is there impl data to store?
            Object impl = sm.getImplData(index);
            if (impl != null && sm.isImplDataCacheable(index))
                setImplData(index, impl);
        } else
            setImplData(index, null);
}

Store impl data for the given field.

 protected  void storeIntermediate(OpenJPAStateManager sm,
    FieldMetaData fmd) 
{
        int index = fmd.getIndex();
        Object val = sm.getIntermediate(index);
        if (val != null)
            setIntermediate(index, val);
}

Store the intermediate field value for the given field.

 protected  void storeVersion(OpenJPAStateManager sm) 
{
        setVersion(sm.getVersion());
}

Store version information from the given state manager.