001 /** 002 * Licensed to the Apache Software Foundation (ASF) under one or more 003 * contributor license agreements. See the NOTICE file distributed with 004 * this work for additional information regarding copyright ownership. 005 * The ASF licenses this file to You under the Apache License, Version 2.0 006 * (the "License"); you may not use this file except in compliance with 007 * the License. You may obtain a copy of the License at 008 * 009 * http://www.apache.org/licenses/LICENSE-2.0 010 * 011 * Unless required by applicable law or agreed to in writing, software 012 * distributed under the License is distributed on an "AS IS" BASIS, 013 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 014 * See the License for the specific language governing permissions and 015 * limitations under the License. 016 */ 017 package org.apache.activemq.store; 018 019 import java.io.IOException; 020 import java.util.concurrent.Future; 021 022 import org.apache.activemq.broker.ConnectionContext; 023 import org.apache.activemq.command.ActiveMQDestination; 024 import org.apache.activemq.command.Message; 025 import org.apache.activemq.command.MessageAck; 026 import org.apache.activemq.command.MessageId; 027 import org.apache.activemq.command.SubscriptionInfo; 028 import org.apache.activemq.usage.MemoryUsage; 029 030 /** 031 * A simple proxy that delegates to another MessageStore. 032 */ 033 public class ProxyTopicMessageStore implements TopicMessageStore { 034 035 final TopicMessageStore delegate; 036 037 public ProxyTopicMessageStore(TopicMessageStore delegate) { 038 this.delegate = delegate; 039 } 040 041 public MessageStore getDelegate() { 042 return delegate; 043 } 044 045 @Override 046 public void addMessage(ConnectionContext context, Message message) throws IOException { 047 delegate.addMessage(context, message); 048 } 049 050 @Override 051 public void addMessage(ConnectionContext context, Message message, boolean canOptimizeHint) throws IOException { 052 delegate.addMessage(context, message, canOptimizeHint); 053 } 054 055 @Override 056 public Message getMessage(MessageId identity) throws IOException { 057 return delegate.getMessage(identity); 058 } 059 060 @Override 061 public void recover(MessageRecoveryListener listener) throws Exception { 062 delegate.recover(listener); 063 } 064 065 @Override 066 public void removeAllMessages(ConnectionContext context) throws IOException { 067 delegate.removeAllMessages(context); 068 } 069 070 @Override 071 public void removeMessage(ConnectionContext context, MessageAck ack) throws IOException { 072 delegate.removeMessage(context, ack); 073 } 074 075 @Override 076 public void start() throws Exception { 077 delegate.start(); 078 } 079 080 @Override 081 public void stop() throws Exception { 082 delegate.stop(); 083 } 084 085 @Override 086 public SubscriptionInfo lookupSubscription(String clientId, String subscriptionName) throws IOException { 087 return delegate.lookupSubscription(clientId, subscriptionName); 088 } 089 090 @Override 091 public void acknowledge(ConnectionContext context, String clientId, String subscriptionName, 092 MessageId messageId, MessageAck ack) throws IOException { 093 delegate.acknowledge(context, clientId, subscriptionName, messageId, ack); 094 } 095 096 @Override 097 public void addSubsciption(SubscriptionInfo subscriptionInfo, boolean retroactive) throws IOException { 098 delegate.addSubsciption(subscriptionInfo, retroactive); 099 } 100 101 @Override 102 public void deleteSubscription(String clientId, String subscriptionName) throws IOException { 103 delegate.deleteSubscription(clientId, subscriptionName); 104 } 105 106 @Override 107 public void recoverSubscription(String clientId, String subscriptionName, MessageRecoveryListener listener) 108 throws Exception { 109 delegate.recoverSubscription(clientId, subscriptionName, listener); 110 } 111 112 @Override 113 public void recoverNextMessages(String clientId, String subscriptionName, int maxReturned, 114 MessageRecoveryListener listener) throws Exception { 115 delegate.recoverNextMessages(clientId, subscriptionName, maxReturned, listener); 116 } 117 118 @Override 119 public void resetBatching(String clientId, String subscriptionName) { 120 delegate.resetBatching(clientId, subscriptionName); 121 } 122 123 @Override 124 public ActiveMQDestination getDestination() { 125 return delegate.getDestination(); 126 } 127 128 @Override 129 public SubscriptionInfo[] getAllSubscriptions() throws IOException { 130 return delegate.getAllSubscriptions(); 131 } 132 133 @Override 134 public void setMemoryUsage(MemoryUsage memoryUsage) { 135 delegate.setMemoryUsage(memoryUsage); 136 } 137 138 @Override 139 public int getMessageCount(String clientId, String subscriberName) throws IOException { 140 return delegate.getMessageCount(clientId, subscriberName); 141 } 142 143 @Override 144 public int getMessageCount() throws IOException { 145 return delegate.getMessageCount(); 146 } 147 148 @Override 149 public void recoverNextMessages(int maxReturned, MessageRecoveryListener listener) throws Exception { 150 delegate.recoverNextMessages(maxReturned, listener); 151 } 152 153 @Override 154 public void dispose(ConnectionContext context) { 155 delegate.dispose(context); 156 } 157 158 @Override 159 public void resetBatching() { 160 delegate.resetBatching(); 161 } 162 163 @Override 164 public void setBatch(MessageId messageId) throws Exception { 165 delegate.setBatch(messageId); 166 } 167 168 @Override 169 public boolean isEmpty() throws Exception { 170 return delegate.isEmpty(); 171 } 172 173 @Override 174 public Future<Object> asyncAddTopicMessage(ConnectionContext context, Message message) throws IOException { 175 return delegate.asyncAddTopicMessage(context, message); 176 } 177 178 @Override 179 public Future<Object> asyncAddTopicMessage(ConnectionContext context, Message message, boolean canOptimizeHint) throws IOException { 180 return delegate.asyncAddTopicMessage(context,message, canOptimizeHint); 181 } 182 183 @Override 184 public Future<Object> asyncAddQueueMessage(ConnectionContext context, Message message) throws IOException { 185 return delegate.asyncAddQueueMessage(context, message); 186 } 187 188 @Override 189 public Future<Object> asyncAddQueueMessage(ConnectionContext context, Message message, boolean canOptimizeHint) throws IOException { 190 return delegate.asyncAddQueueMessage(context,message, canOptimizeHint); 191 } 192 193 @Override 194 public void removeAsyncMessage(ConnectionContext context, MessageAck ack) throws IOException { 195 delegate.removeAsyncMessage(context, ack); 196 } 197 198 @Override 199 public void setPrioritizedMessages(boolean prioritizedMessages) { 200 delegate.setPrioritizedMessages(prioritizedMessages); 201 } 202 203 @Override 204 public boolean isPrioritizedMessages() { 205 return delegate.isPrioritizedMessages(); 206 } 207 }