public QueryCacheStoreQuery(StoreQuery query,
    QueryCache cache) 
{
        _query = query;
        _cache = cache;
}

Create a new instance that delegates to query if no cached results are available.

 public AggregateListener getAggregateListener(String tag) 
{
        return _query.getAggregateListener(tag);
}

 public QueryCache getCache() 
{
        return _cache;
}

Return the QueryCache that this object is associated with.

 public QueryContext getContext() 
{
        return _query.getContext();
}

 public StoreQuery getDelegate() 
{
        return _query;
}

Delegate.

 public FilterListener getFilterListener(String tag) 
{
        return _query.getFilterListener(tag);
}

 public  void invalidateCompilation() 
{
        _query.invalidateCompilation();
}

 public Object newCompilation() 
{
        return _query.newCompilation();
}

 public Object newCompilationKey() 
{
        return _query.newCompilationKey();
}

 public Executor newDataStoreExecutor(ClassMetaData meta,
    boolean subs) 
{
        Executor ex = _query.newDataStoreExecutor(meta, subs);
        return new QueryCacheExecutor(ex, meta, subs);
}

 public Executor newInMemoryExecutor(ClassMetaData meta,
    boolean subs) 
{
        return _query.newInMemoryExecutor(meta, subs);
}

 public  void populateFromCompilation(Object comp) 
{
        _query.populateFromCompilation(comp);
}

 public boolean requiresCandidateType() 
{
        return _query.requiresCandidateType();
}

 public boolean requiresParameterDeclarations() 
{
        return _query.requiresParameterDeclarations();
}

 public  void setContext(QueryContext qctx) 
{
        _query.setContext(qctx);
        _sctx = qctx.getStoreContext();
        _repos = _sctx.getConfiguration().getMetaDataRepositoryInstance();
}

 public boolean setQuery(Object query) 
{
        return _query.setQuery(query);
}

 public boolean supportsAbstractExecutors() 
{
        return _query.supportsAbstractExecutors();
}

 public boolean supportsDataStoreExecution() 
{
        return _query.supportsDataStoreExecution();
}

 public boolean supportsInMemoryExecution() 
{
        return _query.supportsInMemoryExecution();
}

 public boolean supportsParameterDeclarations() 
{
        return _query.supportsParameterDeclarations();
}

 public Object writeReplace() throws ObjectStreamException 
{
        return _query;
}