public BrokerFilter(Broker next) 
{
        this.next = next;
}

 public  void acknowledge(ConsumerBrokerExchange consumerExchange,
    MessageAck ack) throws Exception 
{
        next.acknowledge(consumerExchange, ack);
}

 public  void addBroker(Connection connection,
    BrokerInfo info) 
{
        next.addBroker(connection, info);
}

 public  void addConnection(ConnectionContext context,
    ConnectionInfo info) throws Exception 
{
        next.addConnection(context, info);
}

 public Subscription addConsumer(ConnectionContext context,
    ConsumerInfo info) throws Exception 
{
        return next.addConsumer(context, info);
}

 public Destination addDestination(ConnectionContext context,
    ActiveMQDestination destination) throws Exception 
{
        return next.addDestination(context, destination);
}

 public  void addDestinationInfo(ConnectionContext context,
    DestinationInfo info) throws Exception 
{
        next.addDestinationInfo(context, info);
}

 public  void addProducer(ConnectionContext context,
    ProducerInfo info) throws Exception 
{
        next.addProducer(context, info);
}

 public  void addSession(ConnectionContext context,
    SessionInfo info) throws Exception 
{
        next.addSession(context, info);
}

 public  void beginTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        next.beginTransaction(context, xid);
}

 public  void brokerServiceStarted() 
{
        next.brokerServiceStarted();
}

 public  void commitTransaction(ConnectionContext context,
    TransactionId xid,
    boolean onePhase) throws Exception 
{
        next.commitTransaction(context, xid, onePhase);
}

 public  void fastProducer(ConnectionContext context,
    ProducerInfo producerInfo) 
{
        next.fastProducer(context, producerInfo);
}

 public  void forgetTransaction(ConnectionContext context,
    TransactionId transactionId) throws Exception 
{
        next.forgetTransaction(context, transactionId);
}

 public  void gc() 
{
        next.gc();
}

 public Broker getAdaptor(Class type) 
{
        if (type.isInstance(this)) {
            return this;
        }
        return next.getAdaptor(type);
}

 public ConnectionContext getAdminConnectionContext() 
{
        return next.getAdminConnectionContext();
}

 public BrokerId getBrokerId() 
{
        return next.getBrokerId();
}

 public String getBrokerName() 
{
        return next.getBrokerName();
}

 public long getBrokerSequenceId() 
{
        return next.getBrokerSequenceId();
}

 public BrokerService getBrokerService() 
{
        return next.getBrokerService();
}

 public Connection[] getClients() throws Exception 
{
        return next.getClients();
}

 public Map<ActiveMQDestination, Destination> getDestinationMap() 
{
        return next.getDestinationMap();
}

 public ActiveMQDestination[] getDestinations() throws Exception 
{
        return next.getDestinations();
}

 public Set<Destination> getDestinations(ActiveMQDestination destination) 
{
        return next.getDestinations(destination);
}

 public Set<ActiveMQDestination> getDurableDestinations() 
{
        return next.getDurableDestinations();
}

 public BrokerInfo[] getPeerBrokerInfos() 
{
        return next.getPeerBrokerInfos();
}

 public TransactionId[] getPreparedTransactions(ConnectionContext context) throws Exception 
{
        return next.getPreparedTransactions(context);
}

 public Broker getRoot() 
{
        return next.getRoot();
}

 public Store getTempDataStore() 
{
        return next.getTempDataStore();
}

 public URI getVmConnectorURI() 
{
        return next.getVmConnectorURI();
}

 public boolean isExpired(MessageReference messageReference) 
{
        return next.isExpired(messageReference);
}

 public boolean isFaultTolerantConfiguration() 
{
        return next.isFaultTolerantConfiguration();
}

 public  void isFull(ConnectionContext context,
    Destination destination,
    Usage usage) 
{
        next.isFull(context,destination, usage);
}

 public boolean isStopped() 
{
        return next.isStopped();
}

 public  void messageConsumed(ConnectionContext context,
    MessageReference messageReference) 
{
        next.messageConsumed(context, messageReference);
}

 public  void messageDelivered(ConnectionContext context,
    MessageReference messageReference) 
{
        next.messageDelivered(context, messageReference);
}

 public  void messageDiscarded(ConnectionContext context,
    MessageReference messageReference) 
{
        next.messageDiscarded(context, messageReference);
}

 public  void messageExpired(ConnectionContext context,
    MessageReference message) 
{
        next.messageExpired(context, message);
}

 public Response messagePull(ConnectionContext context,
    MessagePull pull) throws Exception 
{
        return next.messagePull(context, pull);
}

 public  void nowMasterBroker() 
{
   
        next.nowMasterBroker();
}

 public  void postProcessDispatch(MessageDispatch messageDispatch) 
{
        next.postProcessDispatch(messageDispatch);
}

 public  void preProcessDispatch(MessageDispatch messageDispatch) 
{
        next.preProcessDispatch(messageDispatch);
}

 public int prepareTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        return next.prepareTransaction(context, xid);
}

 public  void processDispatchNotification(MessageDispatchNotification messageDispatchNotification) throws Exception 
{
        next.processDispatchNotification(messageDispatchNotification);
}

 public  void removeBroker(Connection connection,
    BrokerInfo info) 
{
        next.removeBroker(connection, info);
}

 public  void removeConnection(ConnectionContext context,
    ConnectionInfo info,
    Throwable error) throws Exception 
{
        next.removeConnection(context, info, error);
}

 public  void removeConsumer(ConnectionContext context,
    ConsumerInfo info) throws Exception 
{
        next.removeConsumer(context, info);
}

 public  void removeDestination(ConnectionContext context,
    ActiveMQDestination destination,
    long timeout) throws Exception 
{
        next.removeDestination(context, destination, timeout);
}

 public  void removeDestinationInfo(ConnectionContext context,
    DestinationInfo info) throws Exception 
{
        next.removeDestinationInfo(context, info);
}

 public  void removeProducer(ConnectionContext context,
    ProducerInfo info) throws Exception 
{
        next.removeProducer(context, info);
}

 public  void removeSession(ConnectionContext context,
    SessionInfo info) throws Exception 
{
        next.removeSession(context, info);
}

 public  void removeSubscription(ConnectionContext context,
    RemoveSubscriptionInfo info) throws Exception 
{
        next.removeSubscription(context, info);
}

 public  void rollbackTransaction(ConnectionContext context,
    TransactionId xid) throws Exception 
{
        next.rollbackTransaction(context, xid);
}

 public  void send(ProducerBrokerExchange producerExchange,
    Message messageSend) throws Exception 
{
        next.send(producerExchange, messageSend);
}

 public  void sendToDeadLetterQueue(ConnectionContext context,
    MessageReference messageReference) 
{
        next.sendToDeadLetterQueue(context, messageReference);
}

 public  void setAdminConnectionContext(ConnectionContext adminConnectionContext) 
{
        next.setAdminConnectionContext(adminConnectionContext);
}

 public  void slowConsumer(ConnectionContext context,
    Destination destination,
    Subscription subs) 
{
        next.slowConsumer(context, destination,subs);
}

 public  void start() throws Exception 
{
        next.start();
}

 public  void stop() throws Exception 
{
        next.stop();
}