public DelegatingStoreManager(StoreManager store) 
{
        _store = store;
        if (store instanceof DelegatingStoreManager)
            _del = (DelegatingStoreManager) _store;
        else
            _del = null;
}

Constructor. Supply delegate.

 public boolean assignField(OpenJPAStateManager sm,
    int field,
    boolean preFlush) 
{
        return _store.assignField(sm, field, preFlush);
}

 public boolean assignObjectId(OpenJPAStateManager sm,
    boolean preFlush) 
{
        return _store.assignObjectId(sm, preFlush);
}

 public  void beforeStateChange(OpenJPAStateManager sm,
    PCState fromState,
    PCState toState) 
{
        _store.beforeStateChange(sm, fromState, toState);
}

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

 public  void beginOptimistic() 
{
        _store.beginOptimistic();
}

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

 public  void close() 
{
        _store.close();
}

 public  void commit() 
{
        _store.commit();
}

 public int compareVersion(OpenJPAStateManager state,
    Object v1,
    Object v2) 
{
        return _store.compareVersion(state, v1, v2);
}

 public Object copyDataStoreId(Object oid,
    ClassMetaData meta) 
{
        return _store.copyDataStoreId(oid, meta);
}

 public boolean equals(Object other) 
{
        if (other == this)
            return true;
        if (other instanceof DelegatingStoreManager)
            other = ((DelegatingStoreManager) other).getInnermostDelegate();
        return getInnermostDelegate().equals(other);
}

 public ResultObjectProvider executeExtent(ClassMetaData meta,
    boolean subclasses,
    FetchConfiguration fetch) 
{
        return _store.executeExtent(meta, subclasses, fetch);
}

 public boolean exists(OpenJPAStateManager sm,
    Object context) 
{
        return _store.exists(sm, context);
}

 public Collection flush(Collection sms) 
{
        return _store.flush(sms);
}

 public Object getClientConnection() 
{
        return _store.getClientConnection();
}

 public Seq getDataStoreIdSequence(ClassMetaData forClass) 
{
        return _store.getDataStoreIdSequence(forClass);
}

 public Class getDataStoreIdType(ClassMetaData meta) 
{
        return _store.getDataStoreIdType(meta);
}

 public StoreManager getDelegate() 
{
        return _store;
}

Return the wrapped store manager.

 public StoreManager getInnermostDelegate() 
{
        return (_del == null) ? _store : _del.getInnermostDelegate();
}

Return the base underlying native store manager.

 public Class getManagedType(Object oid) 
{
        return _store.getManagedType(oid);
}

 public Seq getValueSequence(FieldMetaData fmd) 
{
        return _store.getValueSequence(fmd);
}

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

 public boolean initialize(OpenJPAStateManager sm,
    PCState state,
    FetchConfiguration fetch,
    Object context) 
{
        return _store.initialize(sm, state, fetch, context);
}

 public boolean load(OpenJPAStateManager sm,
    BitSet fields,
    FetchConfiguration fetch,
    int lockLevel,
    Object context) 
{
        return _store.load(sm, fields, fetch, lockLevel, context);
}

 public Collection loadAll(Collection sms,
    PCState state,
    int load,
    FetchConfiguration fetch,
    Object context) 
{
        return _store.loadAll(sms, state, load, fetch, context);
}

 public Object newDataStoreId(Object oidVal,
    ClassMetaData meta) 
{
        return _store.newDataStoreId(oidVal, meta);
}

 public FetchConfiguration newFetchConfiguration() 
{
        return _store.newFetchConfiguration();
}

 public StoreQuery newQuery(String language) 
{
        return _store.newQuery(language);
}

 public  void releaseConnection() 
{
        _store.releaseConnection();
}

 public  void retainConnection() 
{
        _store.retainConnection();
}

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

 public  void rollbackOptimistic() 
{
        _store.rollbackOptimistic();
}

 public  void setContext(StoreContext ctx) 
{
        _store.setContext(ctx);
}

 public boolean syncVersion(OpenJPAStateManager sm,
    Object context) 
{
        return _store.syncVersion(sm, context);
}