public  void add(ConnectionContext context,
    Destination destination) throws Exception 
{

}

 public  void addMessageFirst(MessageReference node) throws Exception 
{

}

 public  void addMessageLast(MessageReference node) throws Exception 
{

}

 public  void addRecoveredMessage(MessageReference node) throws Exception 
{
        addMessageLast(node);
}

 public  void clear() 
{

}

 public  void destroy() throws Exception 
{
        stop();
}

destroy the cursor

 protected  void fillBatch() throws Exception 
{

}

 public  void gc() 
{

}

 public int getMaxAuditDepth() 
{
        return maxAuditDepth;
}

 public int getMaxBatchSize() 
{
        return maxBatchSize;
}

 public int getMaxProducersToAudit() 
{
        return maxProducersToAudit;
}

 public int getMemoryUsageHighWaterMark() 
{
        return memoryUsageHighWaterMark;
}

 public ActiveMQMessageAudit getMessageAudit() 
{
    	return audit;
}

 public SystemUsage getSystemUsage() 
{
        return this.systemUsage;
}

 public boolean hasMessagesBufferedToDeliver() 
{
        return false;
}

 public boolean hasNext() 
{
        return false;
}

 public boolean hasSpace() 
{
        return systemUsage != null ? (systemUsage.getMemoryUsage().getPercentUsage() <  memoryUsageHighWaterMark) : true;
}

 public synchronized boolean isDuplicate(MessageId messageId) 
{
        boolean unique = recordUniqueId(messageId);
        rollback(messageId);
        return !unique;
}

 public boolean isEmpty() 
{
        return false;
}

 public boolean isEmpty(Destination destination) 
{
        return isEmpty();
}

 public boolean isEnableAudit() 
{
        return enableAudit;
}

 public boolean isFull() 
{
        return systemUsage != null ? systemUsage.getMemoryUsage().isFull() : false;
}

 public boolean isRecoveryRequired() 
{
        return true;
}

 protected synchronized boolean isStarted() 
{
        return started;
}

 public boolean isTransient() 
{
        return false;
}

 public boolean isUseCache() 
{
        return useCache;
}

 public MessageReference next() 
{
        return null;
}

 public LinkedList<MessageReference> pageInList(int maxItems) 
{
        throw new RuntimeException("Not supported");
}

Page in a restricted number of messages

 public synchronized boolean recordUniqueId(MessageId messageId) 
{
        if (!enableAudit || audit==null) {
            return true;
        }
        return !audit.isDuplicate(messageId);
}

records a message id and checks if it is a duplicate

 public  void release() 
{

}

 public  void remove() 
{

}

 public  void remove(MessageReference node) 
{

}

 public List<MessageReference> remove(ConnectionContext context,
    Destination destination) throws Exception 
{
        return Collections.EMPTY_LIST;
}

 public  void reset() 
{

}

 public  void resetForGC() 
{
        reset();
}

 public synchronized  void rollback(MessageId id) 
{
        if (audit != null) {
            audit.rollback(id);
        }
}

 public synchronized  void setEnableAudit(boolean enableAudit) 
{
        this.enableAudit = enableAudit;
        if (enableAudit && started && audit==null) {
            audit= new ActiveMQMessageAudit(maxAuditDepth,maxProducersToAudit);
        }
}

 public synchronized  void setMaxAuditDepth(int maxAuditDepth) 
{
        this.maxAuditDepth = maxAuditDepth;
        if (audit != null) {
            audit.setAuditDepth(maxAuditDepth);
        }
}

 public  void setMaxBatchSize(int maxBatchSize) 
{
        this.maxBatchSize = maxBatchSize;
}

 public synchronized  void setMaxProducersToAudit(int maxProducersToAudit) 
{
        this.maxProducersToAudit = maxProducersToAudit;
        if (audit != null) {
            audit.setMaximumNumberOfProducersToTrack(maxProducersToAudit);
        }
}

 public  void setMemoryUsageHighWaterMark(int memoryUsageHighWaterMark) 
{
        this.memoryUsageHighWaterMark = memoryUsageHighWaterMark;
}

 public  void setMessageAudit(ActiveMQMessageAudit audit) 
{
    	this.audit=audit;
}

set the audit

 public  void setSystemUsage(SystemUsage usageManager) 
{
        this.systemUsage = usageManager;
}

 public  void setUseCache(boolean useCache) 
{
        this.useCache = useCache;
}

 public int size() 
{
        return 0;
}

 public synchronized  void start() throws Exception 
{
        if (!started && enableAudit && audit==null) {
            audit= new ActiveMQMessageAudit(maxAuditDepth,maxProducersToAudit);
        }
        started=true;
}

 public synchronized  void stop() throws Exception 
{
        started=false;
        audit=null;
        gc();
}